| /* |
| ================================================================================== |
| Copyright (c) 2019 AT&T Intellectual Property. |
| Copyright (c) 2019 Nokia |
| |
| Licensed under the Apache License, Version 2.0 (the "License"); |
| you may not use this file except in compliance with the License. |
| You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| ================================================================================== |
| */ |
| |
| package helm |
| |
| import ( |
| "fmt" |
| "github.com/ghodss/yaml" |
| "github.com/spf13/viper" |
| "io/ioutil" |
| "os" |
| "regexp" |
| "strconv" |
| "strings" |
| "time" |
| |
| "gerrit.o-ran-sc.org/r/ric-plt/appmgr/pkg/appmgr" |
| "gerrit.o-ran-sc.org/r/ric-plt/appmgr/pkg/cm" |
| "gerrit.o-ran-sc.org/r/ric-plt/appmgr/pkg/models" |
| "gerrit.o-ran-sc.org/r/ric-plt/appmgr/pkg/util" |
| ) |
| |
| var kubeExec = util.KubectlExec |
| var helmExec = util.HelmExec |
| |
| type Helm struct { |
| initDone bool |
| cm *cm.CM |
| } |
| |
| func GetHelmVersion() { |
| var temp string |
| temp = os.Getenv("HELMVERSION") |
| if temp == "" { |
| temp = "v2.12.3" |
| } |
| appmgr.Logger.Info("Inside new Helm") |
| temp = strings.TrimLeft(temp,"v") |
| cm.EnvHelmVersion = string(temp[0:1]) //s.TrimRight(temp, ".") |
| appmgr.Logger.Info(cm.EnvHelmVersion) |
| } |
| |
| |
| func NewHelm() *Helm { |
| GetHelmVersion() |
| return &Helm{initDone: false, cm: cm.NewCM()} |
| } |
| |
| func (h *Helm) Initialize() { |
| if h.initDone == true { |
| return |
| } |
| appmgr.Logger.Info("START") |
| for { |
| if _, err := h.Init(); err == nil { |
| appmgr.Logger.Info("Helm init done successfully!") |
| break |
| } |
| appmgr.Logger.Info("helm init failed, retyring ...") |
| time.Sleep(time.Duration(10) * time.Second) |
| } |
| if cm.EnvHelmVersion == cm.HELM_VERSION_3 { |
| appmgr.Logger.Info("Codintion met for HELM3") |
| util.HelmExec(strings.Join([]string{"repo add stable https://kubernetes-charts.storage.googleapis.com/ "}, "")) |
| } |
| |
| for { |
| if _, err := h.AddRepo(); err == nil { |
| appmgr.Logger.Info("Helm repo added successfully") |
| break |
| } |
| appmgr.Logger.Info("Helm repo addition failed, retyring ...") |
| time.Sleep(time.Duration(10) * time.Second) |
| } |
| h.initDone = true |
| } |
| |
| func (h *Helm) Run(args string) (out []byte, err error) { |
| return helmExec(args) |
| } |
| |
| // API functions |
| func (h *Helm) Init() (out []byte, err error) { |
| if err := h.AddTillerEnv(); err != nil { |
| return out, err |
| } |
| if cm.EnvHelmVersion == cm.HELM_VERSION_2{ |
| appmgr.Logger.Info("Init for Version 2") |
| return helmExec(strings.Join([]string{"init -c --skip-refresh"}, "")) |
| } |
| |
| return out, err |
| } |
| |
| func (h *Helm) AddRepo() (out []byte, err error) { |
| // Get helm repo user name and password from files mounted by secret object |
| username, err := ioutil.ReadFile(viper.GetString("helm.helm-username-file")) |
| if err != nil { |
| appmgr.Logger.Info("helm_repo_username ReadFile failed: %v", err.Error()) |
| return |
| } |
| |
| password, err := ioutil.ReadFile(viper.GetString("helm.helm-password-file")) |
| if err != nil { |
| appmgr.Logger.Info("helm_repo_password ReadFile failed: %v", err.Error()) |
| return |
| } |
| |
| repoArgs := fmt.Sprintf(" %s %s ", viper.GetString("helm.repo-name"), viper.GetString("helm.repo")) |
| credentials := fmt.Sprintf(" --username %s --password %s", string(username), string(password)) |
| |
| return helmExec(strings.Join([]string{"repo add ", repoArgs, credentials}, "")) |
| } |
| |
| func (h *Helm) Install(m models.XappDescriptor) (xapp models.Xapp, err error) { |
| m.Namespace = h.cm.GetNamespace(m.Namespace) |
| |
| out, err := h.Run(strings.Join([]string{"repo update "}, "")) |
| if err != nil { |
| return |
| } |
| |
| out, err = h.Run(h.GetInstallArgs(m, false)) |
| if err != nil { |
| return |
| } |
| return h.ParseStatus(*m.XappName, string(out)) |
| } |
| |
| func (h *Helm) Status(name string) (xapp models.Xapp, err error) { |
| var command string |
| if cm.EnvHelmVersion == cm.HELM_VERSION_3 { |
| names := h.cm.GetNamespace("") |
| command = strings.Join([]string{"status ", name," --namespace ", names}, "") |
| appmgr.Logger.Info ("Status: Version 3") |
| }else { |
| command = strings.Join([]string{"status ", name}, "") |
| appmgr.Logger.Info ("Status: Version 2") |
| } |
| out, err := h.Run(command) |
| |
| if err != nil { |
| appmgr.Logger.Info("Getting xapps status: %v", err.Error()) |
| return |
| } |
| return h.ParseStatus(name, string(out)) |
| } |
| |
| func (h *Helm) StatusAll() (xapps models.AllDeployedXapps, err error) { |
| xappNameList, err := h.List() |
| if err != nil { |
| appmgr.Logger.Info("Helm list failed: %v", err.Error()) |
| return |
| } |
| |
| return h.parseAllStatus(xappNameList) |
| } |
| |
| func (h *Helm) List() (names []string, err error) { |
| ns := h.cm.GetNamespace("") |
| out, err := h.Run(strings.Join([]string{"list --all --deployed --output yaml --namespace=", ns}, "")) |
| if err != nil { |
| appmgr.Logger.Info("Listing deployed xapps failed: %v", err.Error()) |
| return |
| } |
| |
| return h.GetNames(string(out)) |
| } |
| |
| func (h *Helm) SearchAll() models.AllDeployableXapps { |
| return h.cm.GetNamesFromHelmRepo() |
| } |
| |
| func (h *Helm) Delete(name string) (xapp models.Xapp, err error) { |
| xapp, err = h.Status(name) |
| var command string = "" |
| ns := h.cm.GetNamespace("") |
| |
| if err != nil { |
| appmgr.Logger.Info("Fetching xapp status failed: %v", err.Error()) |
| return |
| } |
| if cm.EnvHelmVersion == cm.HELM_VERSION_3 { |
| command = strings.Join([]string{"uninstall ", name," -n ", ns}, "") |
| appmgr.Logger.Info ("DELETE: Version 3") |
| } else { |
| command = strings.Join([]string{"del --purge ", name}, "") |
| appmgr.Logger.Info ("DELETE: Version 2") |
| } |
| _, err = h.Run (command) |
| |
| return xapp, err |
| } |
| |
| func (h *Helm) Fetch(name, tarDir string) error { |
| if strings.HasSuffix(os.Args[0], ".test") { |
| return nil |
| } |
| |
| rname := viper.GetString("helm.repo-name") + "/" |
| |
| _, err := h.Run(strings.Join([]string{"fetch --untar --untardir ", tarDir, " ", rname, name}, "")) |
| return err |
| } |
| |
| // Helper functions |
| func (h *Helm) GetVersion(name string) (version string) { |
| ns := h.cm.GetNamespace("") |
| var command string = "" |
| if cm.EnvHelmVersion == cm.HELM_VERSION_3 { |
| command = strings.Join([]string{"list --deployed --output yaml --namespace=", ns, " ","-f ",name}, "") |
| appmgr.Logger.Info ("GetVersion: Version 3") |
| } else { |
| command = strings.Join([]string{"list --deployed --output yaml --namespace=", ns, " ", name}, "") |
| appmgr.Logger.Info ("GetVersion: Version 2") |
| } |
| out, err := h.Run(command) |
| |
| if err != nil { |
| return |
| } |
| |
| var re = regexp.MustCompile(`AppVersion: .*`) |
| ver := re.FindStringSubmatch(string(out)) |
| if ver != nil { |
| version = strings.Split(ver[0], ": ")[1] |
| version, _ = strconv.Unquote(version) |
| } |
| |
| return |
| } |
| |
| func (h *Helm) GetState(out string) (status string) { |
| re := regexp.MustCompile(`STATUS: .*`) |
| result := re.FindStringSubmatch(string(out)) |
| if result != nil { |
| status = strings.ToLower(strings.Split(result[0], ": ")[1]) |
| } |
| |
| return |
| } |
| |
| func (h *Helm) GetAddress(out string) (ip, port string) { |
| var tmp string |
| re := regexp.MustCompile(`ClusterIP.*`) |
| addr := re.FindStringSubmatch(string(out)) |
| if addr != nil { |
| fmt.Sscanf(addr[0], "%s %s %s %s", &tmp, &ip, &tmp, &port) |
| } |
| |
| return |
| } |
| |
| func (h *Helm) GetEndpointInfo(name string) (svc string, port int) { |
| port = 4560 // Default |
| ns := h.cm.GetNamespace("") |
| args := fmt.Sprintf(" get service -n %s service-%s-%s-rmr -o json", ns, ns, name) |
| out, err := kubeExec(args) |
| if err != nil { |
| return fmt.Sprintf("service-%s-%s-rmr.%s", ns, name, ns), 4560 |
| } |
| appmgr.Logger.Debug("Endpoint IP address of %s: %s", name, string(out)) |
| |
| v, err := h.cm.ParseJson(string(out)) |
| if err != nil { |
| return fmt.Sprintf("service-%s-%s-rmr.%s", ns, name, ns), 4560 |
| } |
| |
| for _, p := range v.GetArray("spec", "ports") { |
| if string(p.GetStringBytes("name")) == "rmrdata" { |
| port = int(p.GetInt("port")) |
| break |
| } |
| } |
| appmgr.Logger.Info("service-%s-%s-rmr.%s %d", ns, name, ns, port) |
| |
| return fmt.Sprintf("service-%s-%s-rmr.%s", ns, name, ns), port |
| } |
| |
| func (h *Helm) GetNames(out string) (names []string, err error) { |
| re := regexp.MustCompile(`Name: .*`) |
| result := re.FindAllStringSubmatch(out, -1) |
| if result == nil { |
| return |
| } |
| |
| for _, v := range result { |
| xappName := strings.Split(v[0], ": ")[1] |
| if strings.Contains(xappName, "appmgr") == false { |
| names = append(names, xappName) |
| } |
| } |
| return names, nil |
| } |
| |
| func (h *Helm) FillInstanceData(name string, out string, xapp *models.Xapp, rtData appmgr.RtmData) { |
| ip, port := h.GetEndpointInfo(name) |
| if ip == "" { |
| appmgr.Logger.Info("Endpoint IP address not found, using CluserIP") |
| ip, _ = h.GetAddress(out) |
| } |
| |
| var tmp string |
| r := regexp.MustCompile(`.*(?s)(Running|Pending|Succeeded|Failed|Unknown).*?\r?\n\r?\n`) |
| result := r.FindStringSubmatch(string(out)) |
| if result == nil { |
| return |
| } |
| |
| re := regexp.MustCompile(name + "-(\\w+-\\w+).*") |
| resources := re.FindAllStringSubmatch(string(result[0]), -1) |
| if resources != nil { |
| for _, v := range resources { |
| var x models.XappInstance |
| var name string |
| fmt.Sscanf(v[0], "%s %s %s", &name, &tmp, &x.Status) |
| x.Name = &name |
| x.Status = strings.ToLower(x.Status) |
| x.IP = ip |
| x.Port = int64(port) |
| x.TxMessages = rtData.TxMessages |
| x.RxMessages = rtData.RxMessages |
| x.Policies = rtData.Policies |
| xapp.Instances = append(xapp.Instances, &x) |
| } |
| } |
| } |
| |
| func (h *Helm) ParseStatus(name string, out string) (xapp models.Xapp, err error) { |
| xapp.Name = &name |
| xapp.Version = h.GetVersion(name) |
| xapp.Status = h.GetState(out) |
| |
| h.FillInstanceData(name, out, &xapp, h.cm.GetRtmData(name)) |
| return |
| } |
| |
| func (h *Helm) parseAllStatus(names []string) (xapps models.AllDeployedXapps, err error) { |
| xapps = models.AllDeployedXapps{} |
| for _, name := range names { |
| var desc interface{} |
| err := h.cm.ReadSchema(name, &desc) |
| if err != nil { |
| continue |
| } |
| |
| x, err := h.Status(name) |
| if err == nil { |
| xapps = append(xapps, &x) |
| } |
| } |
| return |
| } |
| |
| func (h *Helm) AddTillerEnv() (err error) { |
| service := viper.GetString("helm.tiller-service") |
| namespace := viper.GetString("helm.tiller-namespace") |
| port := viper.GetString("helm.tiller-port") |
| |
| if err = os.Setenv("HELM_HOST", service+"."+namespace+":"+port); err != nil { |
| appmgr.Logger.Info("Tiller Env Setting Failed: %v", err.Error()) |
| } |
| return err |
| } |
| |
| func (h *Helm) GetInstallArgs(x models.XappDescriptor, cmOverride bool) (args string) { |
| args = fmt.Sprintf("%s--namespace=%s", args, x.Namespace) |
| if x.HelmVersion != "" { |
| args = fmt.Sprintf("%s --version=%s", args, x.HelmVersion) |
| } |
| |
| if cm.EnvHelmVersion == cm.HELM_VERSION_2 { |
| if x.ReleaseName != "" { |
| args = fmt.Sprintf("%s --name=%s", args, x.ReleaseName) |
| } else { |
| args = fmt.Sprintf("%s --name=%s", args, *x.XappName) |
| appmgr.Logger.Info("") |
| } |
| appmgr.Logger.Info ("GetInstallArgs: Version 2") |
| } |
| |
| if cmOverride == true { |
| args = fmt.Sprintf("%s --set ricapp.appconfig.override=%s-appconfig", args, *x.XappName) |
| } |
| |
| if x.OverrideFile != nil { |
| if overrideYaml, err := yaml.JSONToYAML([]byte(x.OverrideFile.(string))); err == nil { |
| err = ioutil.WriteFile("/tmp/appmgr_override.yaml", overrideYaml, 0644) |
| if err != nil { |
| appmgr.Logger.Info("ioutil.WriteFile(/tmp/appmgr_override.yaml) failed: %v", err) |
| } else { |
| args = args + " -f=/tmp/appmgr_override.yaml" |
| } |
| } else { |
| appmgr.Logger.Info("yaml.JSONToYAML failed: %v", err) |
| } |
| } |
| |
| repoName := viper.GetString("helm.repo-name") |
| if repoName == "" { |
| repoName = "helm-repo" |
| } |
| |
| if cm.EnvHelmVersion == cm.HELM_VERSION_3 { |
| appmgr.Logger.Info ("GetInstallArgs last: Version 3") |
| return fmt.Sprintf("install %s %s/%s %s",*x.XappName, repoName, *x.XappName, args) |
| } else { |
| appmgr.Logger.Info ("GetInstallArgs last: Version 2") |
| return fmt.Sprintf("install %s/%s %s", repoName, *x.XappName, args) |
| } |
| } |