Correction

.gitignore

@@ -0,0 +1 @@
+bin

README.md

@@ -35,69 +35,5 @@ Install Talos
     chmod 700 get_helm.sh
     ./get_helm.sh
 
---------------------------
 # Create OpenCloud Chart
-
-# `oc-deploy` Component
-
-The `oc-deploy` component aims to simplify and automate the deployment of OpenCloud components on a Kubernetes cluster through the creation of Helm Charts.
-
-## Prerequisites:
-- Access to the OpenCloud forge and the associated Harbor registry: [https://registry.o-forge.io/](https://registry.o-forge.io/), which will allow pulling OpenCloud release images from the "stable" project.
-- To test the connection to this registry from the Docker client:
-  ```bash
-  docker login registry.o-forge.io
-  ```
-- A Kubernetes cluster: Minikube, K3s, RKE2, etc. See `KubernetesCluster`.
-- Helm installed locally
-
-## **To Be Defined:**
-### Configuring a Docker Secret for Kubernetes
-Kubernetes needs to know your credentials to pull images from the "registry.o-forge.io" registry. Create a Docker secret in Kubernetes:
-
-```bash
-kubectl create secret docker-registry regcred \
-  --docker-server=registry.o-forge.io \
-  --docker-username=<your_username> \
-  --docker-password=<your_password> \
-  --docker-email=<your_email>
-```
-
-## Checking if Helm Recognizes Your Local Kubernetes Cluster:
-
-### 1. Verify Connection to Kubernetes:
-Before checking Helm, ensure that your `kubectl` is properly configured to connect to your local Kubernetes cluster.
-Run the following command to see if you can communicate with the cluster:
-
-```bash
-kubectl get nodes
-```
-
-
-If this command returns the list of nodes in your cluster, it means `kubectl` is properly connected.
-
-### 2. Verify Helm Configuration:
-Now, you can check if Helm can access the cluster by using the following command:
-
-```bash
-helm version
-```
-
-This command displays the Helm version and the Kubernetes version it is connected to.
-
-## Deploying with Helm:
-You can deploy the `oc-deploy` Chart with Helm:
-
-```bash
-helm install oc-deploy path/to/your/Helm/oc-deploy
-```
-
-
-## Checking Helm Releases:
-You can also list the existing releases to see if Helm is properly connected to the cluster:
-
-```bash
-helm list
-```
-
-If all these commands execute without errors and give the expected results, your Helm installation is correctly configured to recognize and interact with your local Kubernetes cluster
+    helm create occhart

arch/oc-deploy.puml

@@ -1,4 +1,4 @@
-@startuml Arch Diagram
+@startuml
 
 top to bottom direction
 

offline/default_value_1.0.yml

@@ -0,0 +1,7 @@
+---
+
+globals:
+
+composant1:
+
+composant2:

offline/latest.yml

@@ -0,0 +1,3 @@
+---
+
+version: 1.0

offline/oc_1.0.yml

@@ -0,0 +1,41 @@
+---
+# Définition d'une version
+
+version: 1.0
+
+tools:
+  - name: kubectl
+    url: https://dl.k8s.io/release/%s/bin/linux/amd64/kubectl
+    version: v1.30.3
+  - name: helm
+    url: https://get.helm.sh/helm-%s-linux-amd64.tar.gz
+    version: v3.15.4
+
+# helm install my-release <repo>/<chart>
+opencloud:
+  - repository:
+      name: bitnami
+      url: https://charts.bitnami.com/bitnami      # Repository des Charts
+    charts:
+      - name: wordpress
+        chart: bitnami/wordpress
+        version: 23.1.0
+        values: {}
+        helm_opts: --wait-for-jobs
+        helm_filevalues: values-init.yml
+
+      - name: phpmyadmin
+        chart: bitnami/phpmyadmin
+        version: 17.0.4
+        values: {}
+
+  - charts:
+     - name: mongo
+       chart:  ../oc-mongo/mongo
+ 
+  - charts:
+      - name: myfirstrelease
+        chart: myfirstchart-0.1.0.tgz
+        url: https://zzzz/myfirstchart-0.1.0.tgz
+
+# helm install myfirstrelease myfirstchart-0.1.0.tgz

src/.gitignore

@@ -0,0 +1,5 @@
+go.sum
+*_
+.coverage.*
+.*.log
+workspace_*

src/Makefile

@@ -0,0 +1,79 @@
+
+BIN_NAME := oc-deploy
+
+BIN_OPTS := 
+
+##################
+
+SOURCES := $(wildcard *.go) $(wildcard */*.go)
+BIN_DIR = ../bin/
+
+PLUGINS := $(wildcard ../plugins/*/*.go)
+OBJS    := ${PLUGINS:.go=.so}
+
+%.so: %.go
+	go build -buildmode=plugin -o $@ $<
+
+help:
+		@echo
+		@echo 'Usage:'
+		@echo '    make build                Génère les exécutables.'
+		@echo '    make get-deps             Dependency download'
+
+		@echo '    make run BIN_OPTS=...     Go run'
+		@echo '    make run_install BIN_OPTS=...     Go run'
+		@echo '    make run_uninstall BIN_OPTS=...     Go run'
+		@echo '    make exec BIN_OPTS=...    exécutable'
+		@echo '    make exec_install BIN_OPTS=...    exécutable'
+		@echo '    make exec_uninstall BIN_OPTS=...    exécutable'
+		@echo '    make test                 Test.'
+		
+		@echo '    make test                 Test'
+		@echo '    make clean                Clean the directory tree.'
+		@echo
+
+${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)
+	@go run main.go ${BIN_OPTS}
+
+run_generate: $(OBJS)
+	@go run main.go generate ${BIN_OPTS}
+
+run_install: $(OBJS)
+	@go run main.go install ${BIN_OPTS}
+
+run_uninstall: $(OBJS)
+	@go run main.go uninstall ${BIN_OPTS}
+
+exec: ${BIN_DIR}/${BIN_NAME} $(OBJS)
+	@${BIN_DIR}/${BIN_NAME} ${BIN_OPTS}
+
+exec_install: ${BIN_DIR}/${BIN_NAME} $(OBJS)
+	@${BIN_DIR}/${BIN_NAME} install ${BIN_OPTS}
+
+exec_uninstall: ${BIN_DIR}/${BIN_NAME} $(OBJS)
+	@${BIN_DIR}/${BIN_NAME} uninstall ${BIN_OPTS}
+
+clean:
+	@test ! -e ${BIN_DIR}/${BIN_NAME} || rm ${BIN_DIR}/${BIN_NAME}
+	@test ! -e .coverage.out || rm .coverage.out
+	@test ! -e .coverage.html || rm .coverage.html
+	@test ! -e go.sum || rm go.sum
+	@test ! -e .oc-deploy.log || rm .oc-deploy.log
+	@rm -rf workspace_*
+
+.PHONY: test
+test_%:
+	go test oc-deploy/$(subst test_,,$@) -coverprofile=.coverage.out -v
+	@go tool cover -html=.coverage.out -o .coverage.html
+
+test:
+	@go test ./... -coverprofile=.coverage.out -v
+	go tool cover -html=.coverage.out -o .coverage.html

src/chart/conf.go

@@ -0,0 +1,42 @@
+package chart
+
+import (
+    "os"
+    "gopkg.in/yaml.v2"
+)
+
+type ChartData struct {
+    Name string `yaml:"name"`
+    Chart string `yaml:"chart"`
+    Url string `yaml:"url"`
+    Version string `yaml:"version"`
+
+    Opts string `yaml:"helm_opts"`
+    Values string `yaml:"helm_values"`
+    FileValues string `yaml:"helm_filevalues"`
+}
+
+type repoData struct {
+    Name string `yaml:"name"`
+    Url string `yaml:"url"`
+    ForceUpdate bool `yaml:"forceupdate"`
+}
+
+type ChartRepoData struct {
+    Repository repoData `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
+}

src/chart/conf_test.go

@@ -0,0 +1,39 @@
+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, "bitnami", data[0].Repository.Name, "FromConfigFile error")
+    assert.Equal(t, "https://charts.bitnami.com/bitnami", data[0].Repository.Url, "FromConfigFile error")
+
+    wordpress := data[0].Charts[0]
+    assert.Equal(t, "wordpress", wordpress.Name, "FromConfigFile error")
+    assert.Equal(t, "bitnami/wordpress", wordpress.Chart, "FromConfigFile error")
+    assert.Equal(t, "23.1.0", wordpress.Version, "FromConfigFile error")
+
+    phpmyadmin := data[0].Charts[1]
+    assert.Equal(t, "phpmyadmin", phpmyadmin.Name, "FromConfigFile error")
+    assert.Equal(t, "bitnami/phpmyadmin", phpmyadmin.Chart,"FromConfigFile error")
+    assert.Equal(t, "17.0.4", phpmyadmin.Version, "FromConfigFile error")
+
+    data1 := data[1]
+    assert.Equal(t, "", data1.Repository.Name, "FromConfigFile error")
+    assert.Equal(t, "", data1.Repository.Url, "FromConfigFile error")
+
+    myfirstrelease := data1.Charts[0]
+    assert.Equal(t, "myfirstrelease", myfirstrelease.Name, "FromConfigFile error")
+    assert.Equal(t, "https://zzzz/myfirstchart-0.1.0.tgz", myfirstrelease.Url, "FromConfigFile error")
+
+}

src/chart/main_test.go

@@ -0,0 +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)
+}

src/cmd/args.go

@@ -0,0 +1,85 @@
+// Package cmd : Parse les arguments
+
+// Arguments : version ==> version d'OpenCloud
+// Argument : projet ==> nom du projet
+package cmd
+
+import (
+    "github.com/spf13/cobra"
+
+    log "oc-deploy/log_wrapper"
+)
+
+var (
+    context string
+    version string
+    modules []string
+)
+
+
+func cobraInstallCmd() *cobra.Command {
+  return &cobra.Command{
+    Use:   "install",
+    Short: "install",
+    Long: `deploy Charts`,
+    Args: cobra.MaximumNArgs(0),
+    RunE: func(cmd *cobra.Command, args []string) error {
+      return InstallCmd(context, version, modules)
+    },
+    Example: "oc-deploy install --version 1.0 --context ex1",
+  }
+}
+
+func cobraUninstallCmd() *cobra.Command{
+  return &cobra.Command{
+    Use:   "uninstall",
+    Short: "undeploy",
+    Long: `Undeploy`,
+    Args: cobra.MaximumNArgs(0),
+    RunE: func(cmd *cobra.Command, args []string) error {
+      return UninstallCmd(context)
+    },
+    Example: "oc-deploy uninstall --context ex1",
+  }
+}
+
+
+func cobraGenerateCmd() *cobra.Command{
+  return &cobra.Command{
+    Use:   "generate",
+    Short: "generate",
+    Long: "Value",
+    Args: cobra.MaximumNArgs(0),
+    RunE: func(cmd *cobra.Command, args []string) error {
+        return GenerateCmd(context, version)
+    },
+    Example: "oc-deploy generate --version 1.0 --context ex1",
+  }
+}
+
+func Execute() {
+
+    log.Log().Debug().Msg("Execute")
+
+    var rootCmd = &cobra.Command{Use: "oc-deploy"}
+
+    var cmdInstall = cobraInstallCmd()
+    var cmdUninstall = cobraUninstallCmd()
+    var cmdGenerate = cobraGenerateCmd()
+
+    cmdInstall.Flags().StringVarP(&context, "context", "c", "opencloud", "Nom du context")
+    cmdInstall.Flags().StringVarP(&version, "version", "v", "latest", "Version")
+    cmdInstall.Flags().StringArrayVarP(&modules, "modules", "m", []string{}, "modules, ...")
+
+    cmdUninstall.Flags().StringVarP(&context, "context", "c", "opencloud", "Nom du context")
+
+    cmdGenerate.Flags().StringVarP(&context, "context", "c", "opencloud", "Nom du context")
+    cmdGenerate.Flags().StringVarP(&version, "version", "v", "latest", "Version")
+
+    rootCmd.AddCommand(cmdInstall)
+    rootCmd.AddCommand(cmdUninstall)
+    rootCmd.AddCommand(cmdGenerate)
+
+    cobra.CheckErr(rootCmd.Execute())
+
+}

src/cmd/args_test.go

@@ -0,0 +1,9 @@
+package cmd
+
+import (
+    "testing"
+)
+
+func TestExecute(t *testing.T) {
+    Execute()
+}

src/cmd/generateCmd.go

@@ -0,0 +1,28 @@
+package cmd
+
+import (
+
+    log "oc-deploy/log_wrapper"
+
+    "oc-deploy/versionOc"
+    "oc-deploy/generate"
+)
+
+func GenerateCmd(project string, version string) error {
+    log.Log().Info().Msg("Generate >> ")
+
+    version, err := versionOc.GetFromFile(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)
+
+    return err
+}

src/cmd/installCmd.go

@@ -0,0 +1,51 @@
+package cmd
+
+import (
+    "fmt"
+    log "oc-deploy/log_wrapper"
+
+    "oc-deploy/install"
+)
+
+func InstallCmd(context string, version string, modules []string) error {
+    log.Log().Info().Msg("Install >> ")
+
+    log.Log().Info().Msg("  << Contexte  : " + context)
+    if len(modules) > 0 {
+        log.Log().Info().Msg(fmt.Sprintf("  << Modules   : %s", modules))
+    }
+
+    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())
+    }
+
+    obj.SetCommands()
+
+    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(modules)
+    if err != nil {
+        log.Log().Fatal().Msg("  >> " + err.Error())
+    }
+
+    return err
+}

src/cmd/installCmd_test.go

@@ -0,0 +1,41 @@
+package cmd
+
+import (
+    "bytes"
+    "github.com/spf13/cobra"
+
+    "testing"
+
+    "github.com/stretchr/testify/assert"
+)
+
+func TestInstallCommand(t *testing.T) {
+    cmd := cobraInstallCmd()
+
+    inMock := false
+    cmd.RunE = func(cmd *cobra.Command, args []string) error {
+        inMock = true
+        return nil
+    }
+
+    cmd.Execute()
+    assert.Truef(t, inMock, "TestInstallCommand")
+}
+
+func TestInstallCommandErr(t *testing.T) {
+    cmd := cobraUninstallCmd()
+
+    inMock := false
+    cmd.RunE = func(cmd *cobra.Command, args []string) error {
+        inMock = true
+        return nil
+    }
+
+    cmd.SetArgs([]string{"bad"})
+    b := bytes.NewBufferString("")
+    cmd.SetOut(b)
+
+    err := cmd.Execute()
+    assert.Falsef(t, inMock, "TestInstallCommand args")
+    assert.NotNilf(t, err, "TestInstallCommand args")
+}

src/cmd/uninstallCmd.go

@@ -0,0 +1,45 @@
+package cmd
+
+import (
+    "fmt"
+    // "strings"
+    // "github.com/spf13/cobra"
+
+    log "oc-deploy/log_wrapper"
+
+    // "oc-deploy/versionOc"
+    "oc-deploy/install"
+)
+
+func UninstallCmd(context string) error {
+    log.Log().Info().Msg("Uninstall >> ")
+
+    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())
+    }
+
+    return err
+}

src/cmd/uninstallCmd_test.go

@@ -0,0 +1,41 @@
+package cmd
+
+import (
+    "bytes"
+    "github.com/spf13/cobra"
+
+    "testing"
+
+    "github.com/stretchr/testify/assert"
+)
+
+func TestUninstallCommand(t *testing.T) {
+    cmd := cobraUninstallCmd()
+
+    inMock := false
+    cmd.RunE = func(cmd *cobra.Command, args []string) error {
+        inMock = true
+        return nil
+    }
+
+    cmd.Execute()
+    assert.Truef(t, inMock, "TestUninstallCommand")
+}
+
+func TestUninstallCommandErr(t *testing.T) {
+    cmd := cobraUninstallCmd()
+
+    inMock := false
+    cmd.RunE = func(cmd *cobra.Command, args []string) error {
+        inMock = true
+        return nil
+    }
+
+    cmd.SetArgs([]string{"bad"})
+    b := bytes.NewBufferString("")
+    cmd.SetOut(b)
+
+    err := cmd.Execute()
+    assert.Falsef(t, inMock, "TestUninstallCommand args")
+    assert.NotNilf(t, err, "TestUninstallCommand args")
+}

src/generate/generate.go

@@ -0,0 +1,22 @@
+package generate
+
+import (
+    "fmt"
+    "oc-deploy/utils"
+)
+
+type GenerateClass struct {
+    Version string
+    Workspace string
+}
+
+func (this GenerateClass) New() (string, error) {
+    src := fmt.Sprintf("../offline/default_value_%s.yml", this.Version)
+    dst := fmt.Sprintf("%s/default_value.yml", this.Workspace)
+
+    err := utils.CopyFile(src, dst)
+    if err != nil {
+        return "", err
+    }
+    return src, nil
+}

src/go.mod

@@ -0,0 +1,25 @@
+module oc-deploy
+
+go 1.22.0
+
+require (
+	github.com/jarcoal/httpmock v1.3.1
+	github.com/rs/zerolog v1.33.0
+	github.com/spf13/cobra v1.8.1
+	github.com/stretchr/testify v1.9.0
+	gopkg.in/yaml.v2 v2.4.0
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rogpeppe/go-internal v1.11.0 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	golang.org/x/sys v0.22.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

src/helm/chart.go

@@ -0,0 +1,162 @@
+package helm
+
+import (
+    "fmt"
+    "strconv"
+    "os"
+    "strings"
+    "errors"
+    "path/filepath"
+    "encoding/json"
+    log "oc-deploy/log_wrapper"
+)
+
+type HelmChart struct {
+    Bin string
+    Name string
+    Chart string
+    Version string
+    Url 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 HelmCommand) ChartInstall(data HelmChart) (string, error) {
+    bin := this.Bin
+
+    existe, err := this.chartExists(data)
+    if err != nil {
+        return "", err
+    }
+    
+    if existe {
+        return "Existe déjà", nil
+    }
+
+    ficChart := data.Chart
+    // Recherche locale
+    if _, err := os.Stat(ficChart); err != nil {
+    } else {
+        // Recherche voa le Workspace
+        ficChart := filepath.Join(data.Workspace, data.Chart)
+        if _, err := os.Stat(ficChart); err == nil {
+        } else {
+            if data.Url != "" {
+                fmt.Println("============ 52 Télechargement", data.Url)
+            }
+        }
+    }
+
+    msg := fmt.Sprintf("%s install %s %s %s --output json", bin, data.Name, ficChart, data.Opts)
+
+    if data.Version != "" {
+        msg = fmt.Sprintf("%s --version %s", msg, data.Version)
+    }
+
+    if data.FileValues != "" {
+        fic := filepath.Join(data.Workspace, data.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 := this.Exec(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 HelmCommand) ChartUninstall(data HelmChart) (string, error) {
+    bin := this.Bin
+
+    log.Log().Info().Msg("  >> Chart : " + data.Name)
+
+    existe, err := this.chartExists(data)
+    if err != nil {
+        return "", err
+    }
+    if ! existe {
+        return "Non présent", nil
+    }
+
+    msg := fmt.Sprintf("%s uninstall %s", bin, data.Name)
+    log.Log().Debug().Msg(msg)
+
+    cmd_args := strings.Split(msg, " ")
+	cmd := this.Exec(cmd_args[0], cmd_args[1:]...)
+    stdout, err := cmd.CombinedOutput()
+
+    res := string(stdout)
+    res = strings.TrimSuffix(res, "\n")
+
+    log.Log().Debug().Msg(res)
+
+    return res, err
+}
+
+// ../bin/helm list --filter phpmyadminm --short
+func (this HelmCommand) chartExists(data HelmChart) (bool, error) {
+    bin := this.Bin
+
+    msg := fmt.Sprintf("%s list --filter %s --no-headers", bin, data.Name)
+    log.Log().Debug().Msg(msg)
+
+    cmd_args := strings.Split(msg, " ")
+	cmd := this.Exec(cmd_args[0], cmd_args[1:]...)
+    stdout, err := cmd.CombinedOutput()
+    if err != nil {
+        log.Log().Debug().Msg(string(stdout))
+        return false, errors.New(string(stdout))
+    }
+
+    res := string(stdout)
+    res = strings.TrimSuffix(res, "\n")
+
+    log.Log().Debug().Msg(string(stdout))
+    log.Log().Debug().Msg(strconv.FormatBool(res != ""))
+
+    return res != "", nil
+}
+
+// func (this HelmChart) GetRessources() (map[string]string, error) {
+//     hs := HelmStatus{Name: this.Name}
+//     hs.New(this.Bin)
+//     data, _ := hs.getRessources()
+
+//     return data, nil
+// }

src/helm/chart_test.go

@@ -0,0 +1,30 @@
+package helm
+
+import (
+    "testing"
+
+    "github.com/stretchr/testify/assert"
+)
+
+func TestHelmChartExists(t *testing.T){
+    
+	cmd := getCmdHelm(true, `oc-catalog      default 1       2024-09-06 16:01:49.17368605 +0200 CEST deployed        oc-catalog-0.1.0        1.0`)
+
+	data := HelmChart{Name: "oc-catalog"}
+    res, err := cmd.chartExists(data)
+
+    assert.Nilf(t, err, "error message %s", err)
+    assert.Truef(t, res, "TestHelmVersion error")
+}
+
+
+func TestHelmChartNotExists(t *testing.T){
+    
+	cmd := getCmdHelm(true, "\n")
+
+	data := HelmChart{Name: "phpmyadmin"}
+    res, err := cmd.chartExists(data)
+
+    assert.Nilf(t, err, "error message %s", err)
+    assert.Falsef(t, res, "TestHelmVersion error")
+}

src/helm/helm.go

@@ -0,0 +1,22 @@
+package helm
+
+import (
+    "os/exec"
+)
+
+type HelmCommand struct {
+    Bin string
+	Exec func(string,...string) commandExecutor
+}
+
+////
+type commandExecutor interface {
+    Output() ([]byte, error)
+    CombinedOutput() ([]byte, error)
+}
+
+func (this *HelmCommand) New() {
+	this.Exec = func(name string, arg ...string) commandExecutor {
+		return exec.Command(name, arg...)
+	}
+}

src/helm/helm_test.go

@@ -0,0 +1,17 @@
+package helm
+
+
+import (
+    "testing"
+
+    "github.com/stretchr/testify/assert"
+)
+
+func TestHelm(t *testing.T) {
+	cmd := HelmCommand{}
+	cmd.New()
+
+    assert.NotNilf(t, cmd.Exec, "TestHelm %s", "New")
+
+	cmd.Exec("pwd")
+}

src/helm/main_test.go

@@ -0,0 +1,84 @@
+package helm
+
+import (
+    "os"
+    "strings"
+    "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)
+}
+
+// Mock
+
+type MockCommandExecutor struct {
+    // Used to stub the return of the Output method
+    // Could add other properties depending on testing needs
+    output string
+}
+
+// Implements the commandExecutor interface
+func (m *MockCommandExecutor) Output() ([]byte, error) {
+    return []byte(m.output), nil
+}
+
+func (m *MockCommandExecutor) CombinedOutput() ([]byte, error) {
+    return []byte(m.output), nil
+}
+
+//
+
+func getCmdHelm(mock bool, output string) (HelmCommand) {
+    if mock == true {
+
+        mock := func(name string, args ...string) commandExecutor {
+            return &MockCommandExecutor{output: output}
+        }
+    
+        cmd := HelmCommand{Bin: "mock", Exec: mock}
+        return cmd
+    } else {
+        bin := filepath.Join(TEST_BIN_DIR, "helm")
+        os.Chmod(bin, 0700)
+
+        cmd := HelmCommand{Bin: bin}
+        cmd.New()
+        return cmd
+    }
+}
+
+func getCmdsHelm(mock bool, outputs map[string]string) (HelmCommand) {
+    if mock == true {
+
+        mock := func(name string, args ...string) commandExecutor {
+            cmd := strings.TrimSuffix(strings.Join(args," "), " ")
+            output := outputs[cmd]
+            return &MockCommandExecutor{output: output}
+        }
+    
+        cmd := HelmCommand{Bin: "mock", Exec: mock}
+        return cmd
+    } else {
+        bin := filepath.Join(TEST_BIN_DIR, "helm")
+        os.Chmod(bin, 0700)
+
+        cmd := HelmCommand{Bin: bin}
+        cmd.New()
+        return cmd
+    }
+}

src/helm/repo.go

@@ -0,0 +1,98 @@
+package helm
+
+import (
+    "fmt"
+    "strings"
+    "encoding/json"
+
+    log "oc-deploy/log_wrapper"
+    "oc-deploy/utils"
+)
+
+type HelmRepo struct {
+    Name string
+    Repository string		// Url du dépôt
+    ForceUpdate bool
+    Opts string
+}
+
+func (this HelmCommand) AddRepository(repo HelmRepo) (string, error) {
+
+    helm_bin := this.Bin
+
+    force_update := "--force-update=false"
+    if repo.ForceUpdate {
+        force_update = "--force-update=true"
+    } else {
+        list, _ := this.ListRepository()
+        if utils.StringInSlice(repo.Name, list) {
+            return "Existe déjà", nil
+        }
+    }
+
+    msg := fmt.Sprintf("%s repo add %s %s %s %s", helm_bin, repo.Name, repo.Repository, force_update, repo.Opts)
+    log.Log().Debug().Msg(msg)
+
+    msg = strings.TrimSuffix(msg, " ")
+
+    cmd_args := strings.Split(msg, " ")
+	cmd := this.Exec(cmd_args[0], cmd_args[1:]...)
+    stdout, err := cmd.CombinedOutput()
+
+    res := string(stdout)
+    res = strings.TrimSuffix(res, "\n")
+
+    return res, err
+}
+
+type parseList struct {
+    Name string  `json:"name"`
+}
+
+func (this HelmCommand) ListRepository() ([]string, error) {
+
+    helm_bin := this.Bin
+    res := make([]string, 0, 0)
+
+    msg := fmt.Sprintf("%s repo list -o json", helm_bin)
+    log.Log().Debug().Msg(msg)
+
+    cmd_args := strings.Split(msg, " ")
+
+	cmd := this.Exec(cmd_args[0], cmd_args[1:]...)
+    stdout, err := cmd.CombinedOutput()
+	if err != nil {
+		return res, err
+	}
+
+	var objmap []parseList
+
+	err = json.Unmarshal(stdout, &objmap)
+	if err != nil {
+		return res, err
+	}
+
+    for _, ele := range objmap {
+        res = append(res, ele.Name)
+    }
+
+    return res, err
+}
+
+// helm repo remove [NAME]
+func (this HelmCommand) RemoveRepository(repo HelmRepo) (string, error) {
+    helm_bin := this.Bin
+
+    msg := fmt.Sprintf("%s repo remove %s", helm_bin, repo.Name)
+    log.Log().Debug().Msg(msg)
+
+    cmd_args := strings.Split(msg, " ")
+
+	cmd := this.Exec(cmd_args[0], cmd_args[1:]...)
+    stdout, err := cmd.CombinedOutput()
+
+    res := string(stdout)
+    res = strings.TrimSuffix(res, "\n")
+
+    return res, err
+}

src/helm/repo_test.go

@@ -0,0 +1,72 @@
+package helm
+
+import (
+    "testing"
+
+    "github.com/stretchr/testify/assert"
+)
+
+func TestHelmListRepository(t *testing.T){
+    
+	cmd := getCmdHelm(true, `[{"name":"bitnami","url":"https://charts.bitnami.com/bitnami"}]`)
+
+    res, err := cmd.ListRepository()
+
+    assert.Nilf(t, err, "error message %s", err)
+    assert.Equal(t, "bitnami", res[0], "TestHelmVersion error")
+}
+
+func TestHelmRemoveRepository(t *testing.T){
+    
+	cmd := getCmdHelm(true, `"bitnami" has been removed from your repositories`)
+
+    repo := HelmRepo{Name: "bitnami"}
+    res, err := cmd.RemoveRepository(repo)
+
+    assert.Nilf(t, err, "error message %s", err)
+    assert.Equal(t, `"bitnami" has been removed from your repositories`, res, "TestHelmRemoveRepository error")
+}
+
+func TestHelmRemoveRepository2(t *testing.T){
+    
+	cmd := getCmdHelm(true, `Error: no repositories configured`)
+
+    repo := HelmRepo{Name: "bitnami"}
+    res, err := cmd.RemoveRepository(repo)
+
+    assert.Nilf(t, err, "error message %s", err)
+    assert.Equal(t, `Error: no repositories configured`, res, "TestHelmRemoveRepository error")
+}
+
+func TestHelmAddRepositoryNew(t *testing.T){
+
+    cmd_output := map[string]string{
+        "repo list -o json": `[{"name":"repo1","url":"https://repo.com"}]`,
+        "repo add repo2 https://repo2.com --force-update=false": `"repo2" has been added to your repositories"`,
+    }
+
+	cmd := getCmdsHelm(true, cmd_output)
+
+    repo := HelmRepo{Name: "repo2", Repository: "https://repo2.com", ForceUpdate: false}
+    res, err := cmd.AddRepository(repo)
+
+    assert.Nilf(t, err, "error message %s", err)
+    assert.Equal(t, `"repo2" has been added to your repositories"`, res, "TestHelmAddRepositoryNew error")
+}
+
+
+func TestHelmAddRepositoryExists(t *testing.T){
+
+    cmd_output := map[string]string{
+        "repo list -o json": `[{"name":"repo1","url":"https://repo.com"}]`,
+        "version --short": "v3.15.4+gfa9efb0",
+    }
+
+	cmd := getCmdsHelm(true, cmd_output)
+
+    repo := HelmRepo{Name: "repo1", Repository: "https://repo.com", ForceUpdate: false}
+    res, err := cmd.AddRepository(repo)
+
+    assert.Nilf(t, err, "error message %s", err)
+    assert.Equal(t, `Existe déjà`, res, "TestHelmRemoveRepository error")
+}

src/helm/ressources.go

@@ -0,0 +1,70 @@
+package helm
+
+import (
+	// "fmt"
+    "encoding/json"
+)
+////
+
+type parseStatusInfoResourcesMetadata struct {
+    Name string  `json:"name"`
+}
+
+// type parseStatusInfoResourcesPod struct {
+//     Api string  `json:"apiVersion"`
+// }
+
+type parseStatusInfoResourcesStatefulSet struct {
+    Api string  `json:"apiVersion"`
+    Kind string  `json:"kind"`
+    Metadata parseStatusInfoResourcesMetadata  `json:"metadata"`
+}
+
+type parseStatusInfoResourcesDeployment struct {
+    Api string  `json:"apiVersion"`
+    Kind string  `json:"kind"`
+    Metadata parseStatusInfoResourcesMetadata  `json:"metadata"`
+}
+
+type parseStatusInfoResources struct {
+    // Pod []parseStatusInfoResourcesPod  `json:"v1/Pod(related)"`
+    StatefulSet []parseStatusInfoResourcesStatefulSet `json:"v1/StatefulSet"`
+    Deployment []parseStatusInfoResourcesDeployment `json:"v1/Deployment"`
+}
+
+type parseStatusInfo struct {
+    Status string  `json:"status"`
+    Resources parseStatusInfoResources  `json:"Resources"`
+}
+
+
+type parseStatus struct {
+    Name string  `json:"name"`
+    Info parseStatusInfo  `json:"info"`
+}
+
+func  (this HelmCommand) GetRessources(data HelmChart) (map[string]string, error) {
+
+	res := make(map[string]string)
+
+	status, err := this.Status(data)
+	if err != nil {
+		return res, err
+	}
+
+	var objmap parseStatus
+
+	err = json.Unmarshal([]byte(status), &objmap)
+	if err != nil {
+		return res, err
+	}
+
+	for _, ele := range objmap.Info.Resources.StatefulSet {
+		res[ele.Metadata.Name] = ele.Kind
+	}
+	for _, ele := range objmap.Info.Resources.Deployment {
+		res[ele.Metadata.Name] = ele.Kind
+	}
+
+	return res, nil
+}

src/helm/ressources_test.go

@@ -0,0 +1,24 @@
+package helm
+
+import (
+    "os"
+    "path/filepath"
+
+    "testing"
+
+    "github.com/stretchr/testify/assert"
+)
+
+func TestHelmRessources(t *testing.T){
+
+    fileName := filepath.Join(TEST_SRC_DIR, "helm_status.json")
+	res_json, _ := os.ReadFile(fileName)
+
+	cmd := getCmdHelm(true, string(res_json))
+
+    data := HelmChart{Name: "test1"}
+    res, err := cmd.GetRessources(data)
+
+    assert.Nilf(t, err, "error message %s", err)
+    assert.Equal(t, "StatefulSet", res["oc-catalog-oc-catalog"], "TestHelmStatus error")
+}

src/helm/status.go

@@ -0,0 +1,32 @@
+package helm
+
+import (
+    "fmt"
+    "strings"
+	"errors"
+
+    log "oc-deploy/log_wrapper"
+)
+
+// type HelmData struct {
+//     Name string
+// }
+
+func (this HelmCommand) Status(data HelmChart) (string, error) {
+
+    helm_bin := this.Bin
+
+    msg := fmt.Sprintf("%s status %s --show-resources -o json", helm_bin, data.Name)
+    log.Log().Debug().Msg(msg)
+
+    cmd_args := strings.Split(msg, " ")
+
+	cmd := this.Exec(cmd_args[0], cmd_args[1:]...)
+    stdout, err := cmd.CombinedOutput()
+    if err != nil {
+        log.Log().Debug().Msg(string(stdout))
+        return "", errors.New(string(stdout))
+    }
+
+    return string(stdout), nil
+}