test

.gitignore

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

README.md

@@ -35,69 +35,5 @@ Install Talos
     chmod 700 get_helm.sh
     ./get_helm.sh
 
---------------------------
 # Create OpenCloud Chart
-
+    helm create occhart
-# `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

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,75 @@
+
+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 ./... -coverprofile=.coverage.out -v
+	go tool cover -html=.coverage.out -o .coverage.html

src/README.md

@@ -0,0 +1,75 @@
+# Helm
+
+[![Build Status](https://github.com/helm/helm/workflows/release/badge.svg)](https://github.com/helm/helm/actions?workflow=release)
+[![Go Report Card](https://goreportcard.com/badge/github.com/helm/helm)](https://goreportcard.com/report/github.com/helm/helm)
+[![GoDoc](https://img.shields.io/static/v1?label=godoc&message=reference&color=blue)](https://pkg.go.dev/helm.sh/helm/v3)
+[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/3131/badge)](https://bestpractices.coreinfrastructure.org/projects/3131)
+
+Helm is a tool for managing Charts. Charts are packages of pre-configured Kubernetes resources.
+
+Use Helm to:
+
+- Find and use [popular software packaged as Helm Charts](https://artifacthub.io/packages/search?kind=0) to run in Kubernetes
+- Share your own applications as Helm Charts
+- Create reproducible builds of your Kubernetes applications
+- Intelligently manage your Kubernetes manifest files
+- Manage releases of Helm packages
+
+## Helm in a Handbasket
+
+Helm is a tool that streamlines installing and managing Kubernetes applications.
+Think of it like apt/yum/homebrew for Kubernetes.
+
+- Helm renders your templates and communicates with the Kubernetes API
+- Helm runs on your laptop, CI/CD, or wherever you want it to run.
+- Charts are Helm packages that contain at least two things:
+  - A description of the package (`Chart.yaml`)
+  - One or more templates, which contain Kubernetes manifest files
+- Charts can be stored on disk, or fetched from remote chart repositories
+  (like Debian or RedHat packages)
+
+## Install
+
+Binary downloads of the Helm client can be found on [the Releases page](https://github.com/helm/helm/releases/latest).
+
+Unpack the `helm` binary and add it to your PATH and you are good to go!
+
+If you want to use a package manager:
+
+- [Homebrew](https://brew.sh/) users can use `brew install helm`.
+- [Chocolatey](https://chocolatey.org/) users can use `choco install kubernetes-helm`.
+- [Scoop](https://scoop.sh/) users can use `scoop install helm`.
+- [Snapcraft](https://snapcraft.io/) users can use `snap install helm --classic`
+
+To rapidly get Helm up and running, start with the [Quick Start Guide](https://helm.sh/docs/intro/quickstart/).
+
+See the [installation guide](https://helm.sh/docs/intro/install/) for more options,
+including installing pre-releases.
+
+## Docs
+
+Get started with the [Quick Start guide](https://helm.sh/docs/intro/quickstart/) or plunge into the [complete documentation](https://helm.sh/docs)
+
+## Roadmap
+
+The [Helm roadmap uses GitHub milestones](https://github.com/helm/helm/milestones) to track the progress of the project.
+
+## Community, discussion, contribution, and support
+
+You can reach the Helm community and developers via the following channels:
+
+- [Kubernetes Slack](https://kubernetes.slack.com):
+  - [#helm-users](https://kubernetes.slack.com/messages/helm-users)
+  - [#helm-dev](https://kubernetes.slack.com/messages/helm-dev)
+  - [#charts](https://kubernetes.slack.com/messages/charts)
+- Mailing List:
+  - [Helm Mailing List](https://lists.cncf.io/g/cncf-helm)
+- Developer Call: Thursdays at 9:30-10:00 Pacific ([meeting details](https://github.com/helm/community/blob/master/communication.md#meetings))
+
+### Contribution
+
+If you're interested in contributing, please refer to the [Contributing Guide](CONTRIBUTING.md) **before submitting a pull request**.
+
+### Code of conduct
+
+Participation in the Helm community is governed by the [Code of Conduct](code-of-conduct.md).

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,73 @@
+// 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 Execute() {
+
+    log.Log().Debug().Msg("Execute")
+
+    var rootCmd = &cobra.Command{Use: "oc-deploy"}
+
+    var cmdInstall = &cobra.Command{
+        Use:   "install",
+        Short: "deploy",
+        Long: `deploy Charts`,
+        Args: cobra.MaximumNArgs(0),
+        Run: func(cmd *cobra.Command, args []string) {
+          InstallCmd(context, version, modules)
+          },
+        Example: "oc-deploy install --version 1.0 --context ex1",
+      }
+
+    var cmdUninstall = &cobra.Command{
+        Use:   "uninstall",
+        Short: "undeploy",
+        Long: `Undeploy`,
+        Args: cobra.MaximumNArgs(0),
+        Run: func(cmd *cobra.Command, args []string) {
+          UninstallCmd(context)
+        },
+        Example: "oc-deploy uninstall --context ex1",
+      }
+
+      var cmdGenerate = &cobra.Command{
+        Use:   "generate",
+        Short: "generate",
+        Long: "Value",
+        Args: cobra.MaximumNArgs(0),
+        Run: func(cmd *cobra.Command, args []string) {
+            GenerateCmd(context, version)
+        },
+        Example: "oc-deploy generate --version 1.0 --context ex1",
+      }
+
+      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/generateCmd.go

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

src/cmd/installCmd.go

@@ -0,0 +1,50 @@
+package cmd
+
+import (
+    "fmt"
+    log "oc-deploy/log_wrapper"
+
+    "oc-deploy/install"
+)
+
+func InstallCmd(context string, version string, modules []string) {
+    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())
+    }
+
+}

src/cmd/uninstallCmd.go

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

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,159 @@
+package helm
+
+import (
+    "fmt"
+    "strconv"
+    "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
+    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 HelmChart) Install() (string, error) {
+    bin := this.Bin
+
+    existe, err := this.exists()
+    if err != nil {
+        return "", err
+    }
+    
+    if existe {
+        return "Existe déjà", nil
+    }
+
+    ficChart := this.Chart
+    // Recherche locale
+    if _, err := os.Stat(ficChart); err != nil {
+    } else {
+        // Recherche voa le Workspace
+        ficChart := filepath.Join(this.Workspace, this.Chart)
+        if _, err := os.Stat(ficChart); err == nil {
+        } else {
+            if this.Url != "" {
+                fmt.Println("============ 52 Télechargement", this.Url)
+            }
+        }
+    }
+
+    msg := fmt.Sprintf("%s install %s %s %s --output json", bin, this.Name, ficChart, 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 {
+        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/command.go

@@ -0,0 +1,16 @@
+package helm
+
+import (
+)
+
+type HelmCommandInterface interface {
+    Status(string) (string, error)
+    AddRepository(HelmRepo) (string, error)
+}
+
+type HelmCommandData struct {
+    Bin string
+}
+
+type RealHelmCommand HelmCommandData
+

src/helm/main_test.go

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

src/helm/repo.go

@@ -0,0 +1,96 @@
+package helm
+
+import (
+    "fmt"
+    "strings"
+    "os/exec"
+    "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 RealHelmCommand) 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)
+
+    cmd_args := strings.Split(msg, " ")
+
+    cmd := exec.Command(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 RealHelmCommand) 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 := exec.Command(cmd_args[0], cmd_args[1:]...)
+    stdout, err := cmd.CombinedOutput()
+	if err != nil {
+		return res, err
+	}
+
+	var objmap []parseList
+
+	err = json.Unmarshal([]byte(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 RealHelmCommand) 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 := exec.Command(helm_bin, "repo", "remove", repo.Name)
+    stdout, err := cmd.CombinedOutput()
+
+    res := string(stdout)
+    res = strings.TrimSuffix(res, "\n")
+
+    return res, err
+}

src/helm/repo_test.go

@@ -0,0 +1,39 @@
+package helm
+
+import (
+    "fmt"
+    // "os"
+    // "path/filepath"
+
+    "testing"
+
+    "github.com/stretchr/testify/assert"
+)
+
+func TestHelmRepoAdd(t *testing.T) {
+
+    repo := HelmRepo{
+                Bin: "./helm",
+                Name: "repooc",
+                Repository: "https://url",
+                ForceUpdate: true,
+                Opts: ""}
+    fmt.Println(" TestHelmRepoAdd ", repo)
+
+    res, err := repo.AddRepository()
+    fmt.Println("TestHelmRepoAdd.24", res, err)
+}
+
+// helm : not found
+func TestHelmRepoAddErr(t *testing.T) {
+
+    repo := HelmRepo{
+                Bin: "./helm",
+                Name: "repooc",
+                Repository: "https://url",
+                ForceUpdate: true,
+                Opts: ""}
+
+    _, err := repo.AddRepository()
+    assert.NotNilf(t, err, "error message %s", "./helm")
+}

src/helm/ressources.go

@@ -0,0 +1,84 @@
+package helm
+
+import (
+	// "fmt"
+    "encoding/json"
+)
+
+type HelmStatus struct {
+    Name string				// Nom
+	command HelmCommandInterface
+}
+
+func (this *HelmStatus) New(bin string) {
+	this.command = RealHelmCommand{Bin: bin}
+}
+
+func (this *HelmStatus) NewMock(mock HelmCommandInterface) {
+	this.command = mock
+}
+
+////
+
+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 HelmStatus) getRessources() (map[string]string, error) {
+
+	res := make(map[string]string)
+
+	status, err := this.command.Status(this.Name)
+	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,28 @@
+package helm
+
+import (
+    "os"
+    "path/filepath"
+
+    "testing"
+
+    "github.com/stretchr/testify/assert"
+)
+
+type MockCommandStatus HelmCommandData
+
+func TestHelmStatus(t *testing.T){
+
+	hs := HelmStatus{Name: "oc-catalog"}
+	hs.NewMock(MockCommandStatus{})
+
+    data, _ := hs.getRessources()
+    assert.Equal(t, "StatefulSet", data["oc-catalog-oc-catalog"], "TestHelmStatus error")
+}
+
+// Mock
+func (this MockCommandStatus) Status(name string) (string, error) {
+    fileName := filepath.Join(TEST_SRC_DIR, "helm_status.json")
+	data, _ := os.ReadFile(fileName)
+	return string(data), nil
+}

src/helm/status.go

@@ -0,0 +1,30 @@
+package helm
+
+import (
+    "fmt"
+    "strings"
+    "errors"
+    "os/exec"
+
+    log "oc-deploy/log_wrapper"
+)
+
+func (this RealHelmCommand) Status(name string) (string, error) {
+
+    helm_bin := this.Bin
+
+    msg := fmt.Sprintf("%s status %s --show-resources -o json", helm_bin, 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 {
+        log.Log().Debug().Msg(string(stdout))
+        return "", errors.New(string(stdout))
+    }
+
+    return string(stdout), nil
+}
+

src/helm/version.go

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

src/helm/version_test.go

@@ -0,0 +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, "v3.15.4+gfa9efb0", version, "TestHelmVersion error")
+}

src/install/common.go

@@ -0,0 +1,103 @@
+package install
+
+import (
+    "fmt"
+    "errors"
+
+    log "oc-deploy/log_wrapper"
+    "oc-deploy/tool"
+    "oc-deploy/kubectl"
+    "oc-deploy/helm"
+)
+
+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) SetCommands() {
+    helm_bin, _ := this.getToolBin("helm")
+    this.commandHelm = helm.RealHelmCommand{Bin: helm_bin}
+
+    // kubectl_bin, _ := this.getToolBin("kubectl")
+    // this.commandKubectl = helm.RealHelmCommand{Bin: kubectl_bin}
+}
+
+func (this *InstallClass) SetCommandsMock(mock helm.HelmCommandInterface) {
+	this.commandHelm = mock
+}
+
+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
+}

src/install/install.go

@@ -0,0 +1,162 @@
+package install
+
+import (
+    "fmt"
+    "sync"
+    "os"
+
+    log "oc-deploy/log_wrapper"
+    "oc-deploy/utils"
+    "oc-deploy/tool"
+    "oc-deploy/chart"
+    "oc-deploy/helm"
+    "oc-deploy/kubectl"
+    "oc-deploy/versionOc"
+)
+
+type InstallClass struct {
+    Version string
+    Workspace string
+
+    tools []tool.ToolData
+    toolsBin map[string]string
+    charts []chart.ChartRepoData
+
+    commandHelm helm.HelmCommandInterface
+}
+
+func (this *InstallClass) NewInstall() (string, error) {
+
+    // Extraction du fichier de version
+    dst := fmt.Sprintf("%s/oc.yml", this.Workspace)
+    log.Log().Debug().Msg(fmt.Sprintf("Check du fichier de version : %s", dst))
+    if _, err := os.Stat(dst); err == nil {
+        log.Log().Debug().Msg("Existe déjà")
+        version, err := versionOc.GetFromFile(dst)
+        if err != nil {
+            return "", err
+        }
+        this.Version = version
+    } else {
+        log.Log().Debug().Msg("Téléchargement du fichier de version")
+        // version, fileversion, err := versionOc.Get(this.Version)
+        version, fileversion, err := versionOc.GetFromOnline(this.Version)
+        if err != nil {
+            return "", err
+        }
+        this.Version = version
+
+        err = utils.CopyContentFile(fileversion, dst)
+        if err != nil {
+            return "", err
+        }
+    }
+
+    // Lecture du fichier de conf
+    var err error
+    this.tools, err = tool.FromConfigFile(dst)
+    if err != nil {
+        return dst, err
+    }
+    this.charts, _ = chart.FromConfigFile(dst)
+    if err != nil {
+        return dst, err
+    }
+
+    bin_path, _ := this.getToolBin("helm")
+    fmt.Println("Install 67 bin_path", bin_path)
+
+    return dst, nil
+}
+
+
+func (this *InstallClass) ChartRepo() (error) {
+
+    for _, v := range this.charts {
+        if v.Repository.Name != "" {
+            log.Log().Info().Msg(fmt.Sprintf("  >> Helm Repo : %s", v.Repository.Name))
+            repo := helm.HelmRepo{Name: v.Repository.Name,
+                                  Repository: v.Repository.Url,
+                                  ForceUpdate: v.Repository.ForceUpdate}
+            res, err := this.commandHelm.AddRepository(repo)
+            if err != nil {
+                log.Log().Info().Msg(fmt.Sprintf("  <<             %s ", err))
+                return err
+            }
+            log.Log().Info().Msg(fmt.Sprintf("  <<             %s ", res))
+        }
+    }
+    return nil
+}
+
+
+func (this *InstallClass) InstallCharts(modules []string) (error) {
+    helm_bin, _ := this.getToolBin("helm")
+    kubectl_bin, _ := this.getToolBin("kubectl")
+
+    var wg sync.WaitGroup
+
+    for _, v := range this.charts {
+        for _, v1 := range v.Charts {
+            if len(modules) == 0 || stringInSlice(v1.Name, modules) {
+                wg.Add(1)
+
+                go func() {
+                    defer wg.Done()
+                    this.installChart(helm_bin, kubectl_bin, v1)
+                } ()
+            }
+        }
+    }
+    wg.Wait()
+    return nil
+}
+
+func stringInSlice(a string, list []string) bool {
+    for _, b := range list {
+        if b == a {
+            return true
+        }
+    }
+    return false
+}
+
+
+func (this *InstallClass) installChart(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,
+                                Chart: chart.Chart,
+                                Url: chart.Url,
+                                Version: chart.Version,
+                                Workspace: this.Workspace,
+                                Opts: chart.Opts,
+                                Values: chart.Values,
+                                FileValues: chart.FileValues}
+
+
+    res, err := helmchart.Install()
+    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))
+
+    ressources, _ := helmchart.GetRessources()
+
+    for key, value := range ressources {
+        obj := kubectl.KubeObject{Bin: kubectl_bin,
+                                  Kind: value,
+                                  Name: key}
+        err := obj.Wait()
+        if err != nil {
+            log.Log().Error().Msg(fmt.Sprintf("  >>             %s/%s KO (%s)", chart.Name, key, err))
+        } else {
+            log.Log().Info().Msg(fmt.Sprintf("  >>             %s/%s OK", chart.Name, key))
+        }
+
+    }
+    
+}