Upgrade Dockerfile base build image
[ric-plt/appmgr.git] / pkg / helm / helm.go
1 /*
2 ==================================================================================
3   Copyright (c) 2019 AT&T Intellectual Property.
4   Copyright (c) 2019 Nokia
5
6    Licensed under the Apache License, Version 2.0 (the "License");
7    you may not use this file except in compliance with the License.
8    You may obtain a copy of the License at
9
10        http://www.apache.org/licenses/LICENSE-2.0
11
12    Unless required by applicable law or agreed to in writing, software
13    distributed under the License is distributed on an "AS IS" BASIS,
14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15    See the License for the specific language governing permissions and
16    limitations under the License.
17 ==================================================================================
18 */
19
20 package helm
21
22 import (
23         "fmt"
24         "github.com/ghodss/yaml"
25         "github.com/spf13/viper"
26         "io/ioutil"
27         "os"
28         "regexp"
29         "strconv"
30         "strings"
31         "time"
32
33         "gerrit.oran-osc.org/r/ric-plt/appmgr/pkg/appmgr"
34         "gerrit.oran-osc.org/r/ric-plt/appmgr/pkg/cm"
35         "gerrit.oran-osc.org/r/ric-plt/appmgr/pkg/models"
36         "gerrit.oran-osc.org/r/ric-plt/appmgr/pkg/util"
37 )
38
39 type Helm struct {
40         initDone bool
41         cm       *cm.CM
42 }
43
44 func NewHelm() *Helm {
45         return &Helm{initDone: false, cm: cm.NewCM()}
46 }
47
48 func (h *Helm) Initialize() {
49         if h.initDone == true {
50                 return
51         }
52
53         for {
54                 if _, err := h.Init(); err == nil {
55                         appmgr.Logger.Info("Helm init done successfully!")
56                         break
57                 }
58                 appmgr.Logger.Info("helm init failed, retyring ...")
59                 time.Sleep(time.Duration(10) * time.Second)
60         }
61
62         for {
63                 if _, err := h.AddRepo(); err == nil {
64                         appmgr.Logger.Info("Helm repo added successfully")
65                         break
66                 }
67                 appmgr.Logger.Info("Helm repo addition failed, retyring ...")
68                 time.Sleep(time.Duration(10) * time.Second)
69         }
70         h.initDone = true
71 }
72
73 func (h *Helm) Run(args string) (out []byte, err error) {
74         return util.HelmExec(args)
75 }
76
77 // API functions
78 func (h *Helm) Init() (out []byte, err error) {
79         if err := h.AddTillerEnv(); err != nil {
80                 return out, err
81         }
82
83         return util.HelmExec(strings.Join([]string{"init -c --skip-refresh"}, ""))
84 }
85
86 func (h *Helm) AddRepo() (out []byte, err error) {
87         // Get helm repo user name and password from files mounted by secret object
88         username, err := ioutil.ReadFile(viper.GetString("helm.helm-username-file"))
89         if err != nil {
90                 appmgr.Logger.Info("helm_repo_username ReadFile failed: %v", err.Error())
91                 return
92         }
93
94         password, err := ioutil.ReadFile(viper.GetString("helm.helm-password-file"))
95         if err != nil {
96                 appmgr.Logger.Info("helm_repo_password ReadFile failed: %v", err.Error())
97                 return
98         }
99
100         repoArgs := fmt.Sprintf(" %s %s ", viper.GetString("helm.repo-name"), viper.GetString("helm.repo"))
101         credentials := fmt.Sprintf(" --username %s --password %s", string(username), string(password))
102
103         return util.HelmExec(strings.Join([]string{"repo add ", repoArgs, credentials}, ""))
104 }
105
106 func (h *Helm) Install(m models.XappDescriptor) (xapp models.Xapp, err error) {
107         m.Namespace = h.cm.GetNamespace(m.Namespace)
108
109         out, err := h.Run(strings.Join([]string{"repo update "}, ""))
110         if err != nil {
111                 return
112         }
113
114         out, err = h.Run(h.GetInstallArgs(m, false))
115         if err != nil {
116                 return
117         }
118         return h.ParseStatus(*m.XappName, string(out))
119 }
120
121 func (h *Helm) Status(name string) (xapp models.Xapp, err error) {
122         out, err := h.Run(strings.Join([]string{"status ", name}, ""))
123         if err != nil {
124                 appmgr.Logger.Info("Getting xapps status: %v", err.Error())
125                 return
126         }
127
128         return h.ParseStatus(name, string(out))
129 }
130
131 func (h *Helm) StatusAll() (xapps models.AllDeployedXapps, err error) {
132         xappNameList, err := h.List()
133         if err != nil {
134                 appmgr.Logger.Info("Helm list failed: %v", err.Error())
135                 return
136         }
137
138         return h.parseAllStatus(xappNameList)
139 }
140
141 func (h *Helm) List() (names []string, err error) {
142         ns := h.cm.GetNamespace("")
143         out, err := h.Run(strings.Join([]string{"list --all --deployed --output yaml --namespace=", ns}, ""))
144         if err != nil {
145                 appmgr.Logger.Info("Listing deployed xapps failed: %v", err.Error())
146                 return
147         }
148
149         return h.GetNames(string(out))
150 }
151
152 func (h *Helm) SearchAll() models.AllDeployableXapps {
153         return h.cm.GetNamesFromHelmRepo()
154 }
155
156 func (h *Helm) Delete(name string) (xapp models.Xapp, err error) {
157         xapp, err = h.Status(name)
158         if err != nil {
159                 appmgr.Logger.Info("Fetching xapp status failed: %v", err.Error())
160                 return
161         }
162
163         _, err = h.Run(strings.Join([]string{"del --purge ", name}, ""))
164         return xapp, err
165 }
166
167 func (h *Helm) Fetch(name, tarDir string) error {
168         if strings.HasSuffix(os.Args[0], ".test") {
169                 return nil
170         }
171
172         rname := viper.GetString("helm.repo-name") + "/"
173
174         _, err := h.Run(strings.Join([]string{"fetch --untar --untardir ", tarDir, " ", rname, name}, ""))
175         return err
176 }
177
178 // Helper functions
179 func (h *Helm) GetVersion(name string) (version string) {
180         ns := h.cm.GetNamespace("")
181         out, err := h.Run(strings.Join([]string{"list --deployed --output yaml --namespace=", ns, " ", name}, ""))
182         if err != nil {
183                 return
184         }
185
186         var re = regexp.MustCompile(`AppVersion: .*`)
187         ver := re.FindStringSubmatch(string(out))
188         if ver != nil {
189                 version = strings.Split(ver[0], ": ")[1]
190                 version, _ = strconv.Unquote(version)
191         }
192
193         return
194 }
195
196 func (h *Helm) GetState(out string) (status string) {
197         re := regexp.MustCompile(`STATUS: .*`)
198         result := re.FindStringSubmatch(string(out))
199         if result != nil {
200                 status = strings.ToLower(strings.Split(result[0], ": ")[1])
201         }
202
203         return
204 }
205
206 func (h *Helm) GetAddress(out string) (ip, port string) {
207         var tmp string
208         re := regexp.MustCompile(`ClusterIP.*`)
209         addr := re.FindStringSubmatch(string(out))
210         if addr != nil {
211                 fmt.Sscanf(addr[0], "%s %s %s %s", &tmp, &ip, &tmp, &port)
212         }
213
214         return
215 }
216
217 func (h *Helm) GetEndpointInfo(name string) (ip string, port int) {
218         ns := h.cm.GetNamespace("")
219         args := fmt.Sprintf(" get endpoints -o=jsonpath='{.subsets[*].addresses[*].ip}' service-%s-%s-rmr -n %s", ns, name, ns)
220         out, err := util.KubectlExec(args)
221         if err != nil {
222                 return
223         }
224         appmgr.Logger.Info("Endpoint IP address of %s: %s", name, string(out))
225         return fmt.Sprintf("service-%s-%s-rmr.%s", ns, name, ns), 4560
226 }
227
228 func (h *Helm) GetNames(out string) (names []string, err error) {
229         re := regexp.MustCompile(`Name: .*`)
230         result := re.FindAllStringSubmatch(out, -1)
231         if result == nil {
232                 return
233         }
234
235         for _, v := range result {
236                 xappName := strings.Split(v[0], ": ")[1]
237                 if strings.Contains(xappName, "appmgr") == false {
238                         names = append(names, xappName)
239                 }
240         }
241         return names, nil
242 }
243
244 func (h *Helm) FillInstanceData(name string, out string, xapp *models.Xapp, rtData appmgr.RtmData) {
245         ip, port := h.GetEndpointInfo(name)
246         if ip == "" {
247                 appmgr.Logger.Info("Endpoint IP address not found, using CluserIP")
248                 ip, _ = h.GetAddress(out)
249         }
250
251         var tmp string
252         r := regexp.MustCompile(`.*(?s)(Running|Pending|Succeeded|Failed|Unknown).*?\r?\n\r?\n`)
253         result := r.FindStringSubmatch(string(out))
254         if result == nil {
255                 return
256         }
257
258         re := regexp.MustCompile(name + "-(\\w+-\\w+).*")
259         resources := re.FindAllStringSubmatch(string(result[0]), -1)
260         if resources != nil {
261                 for _, v := range resources {
262                         var x models.XappInstance
263                         var name string
264                         fmt.Sscanf(v[0], "%s %s %s", &name, &tmp, &x.Status)
265                         x.Name = &name
266                         x.Status = strings.ToLower(x.Status)
267                         x.IP = ip
268                         x.Port = int64(port)
269                         x.TxMessages = rtData.TxMessages
270                         x.RxMessages = rtData.RxMessages
271                         x.Policies = rtData.Policies
272                         xapp.Instances = append(xapp.Instances, &x)
273                 }
274         }
275 }
276
277 func (h *Helm) ParseStatus(name string, out string) (xapp models.Xapp, err error) {
278         xapp.Name = &name
279         xapp.Version = h.GetVersion(name)
280         xapp.Status = h.GetState(out)
281
282         h.FillInstanceData(name, out, &xapp, h.cm.GetRtmData(name))
283         return
284 }
285
286 func (h *Helm) parseAllStatus(names []string) (xapps models.AllDeployedXapps, err error) {
287         xapps = models.AllDeployedXapps{}
288         for _, name := range names {
289                 var desc interface{}
290                 err := h.cm.ReadSchema(name, &desc)
291                 if err != nil {
292                         continue
293                 }
294
295                 x, err := h.Status(name)
296                 if err == nil {
297                         xapps = append(xapps, &x)
298                 }
299         }
300         return
301 }
302
303 func (h *Helm) AddTillerEnv() (err error) {
304         service := viper.GetString("helm.tiller-service")
305         namespace := viper.GetString("helm.tiller-namespace")
306         port := viper.GetString("helm.tiller-port")
307
308         if err = os.Setenv("HELM_HOST", service+"."+namespace+":"+port); err != nil {
309                 appmgr.Logger.Info("Tiller Env Setting Failed: %v", err.Error())
310         }
311         return err
312 }
313
314 func (h *Helm) GetInstallArgs(x models.XappDescriptor, cmOverride bool) (args string) {
315         args = fmt.Sprintf("%s --namespace=%s", args, x.Namespace)
316         if x.HelmVersion != "" {
317                 args = fmt.Sprintf("%s --version=%s", args, x.HelmVersion)
318         }
319
320         if x.ReleaseName != "" {
321                 args = fmt.Sprintf("%s --name=%s", args, x.ReleaseName)
322         } else {
323                 args = fmt.Sprintf("%s --name=%s", args, *x.XappName)
324         }
325
326         if cmOverride == true {
327                 args = fmt.Sprintf("%s ---set ricapp.appconfig.override=%s-appconfig", args, *x.XappName)
328         }
329
330         if x.OverrideFile != nil {
331                 if overrideYaml, err := yaml.JSONToYAML([]byte(x.OverrideFile.(string))); err == nil {
332                         err = ioutil.WriteFile("/tmp/appmgr_override.yaml", overrideYaml, 0644)
333                         if err != nil {
334                                 appmgr.Logger.Info("ioutil.WriteFile(/tmp/appmgr_override.yaml) failed: %v", err)
335                         } else {
336                                 args = args + " -f=/tmp/appmgr_override.yaml"
337                         }
338                 } else {
339                         appmgr.Logger.Info("yaml.JSONToYAML failed: %v", err)
340                 }
341         }
342
343         repoName := viper.GetString("helm.repo-name")
344         if repoName == "" {
345                 repoName = "helm-repo"
346         }
347         return fmt.Sprintf("install %s/%s %s", repoName, *x.XappName, args)
348 }