2 // ========================LICENSE_START=================================
5 // Copyright (C) 2022: Nordix Foundation
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
11 // http://www.apache.org/licenses/LICENSE-2.0
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
18 // ========================LICENSE_END===================================
29 "github.com/pkg/errors"
31 "helm.sh/helm/v3/pkg/action"
32 "helm.sh/helm/v3/pkg/chart"
33 "helm.sh/helm/v3/pkg/chart/loader"
34 "helm.sh/helm/v3/pkg/cli"
35 "helm.sh/helm/v3/pkg/getter"
36 "helm.sh/helm/v3/pkg/kube"
37 "helm.sh/helm/v3/pkg/repo"
39 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
40 "k8s.io/cli-runtime/pkg/genericclioptions"
41 kubernetes "k8s.io/client-go/kubernetes"
42 "k8s.io/client-go/rest"
48 var settings *cli.EnvSettings
49 var chartRequested *chart.Chart
54 var releaseName string
57 type ChartInfo struct {
58 Name string `json:",omitempty"`
59 Namespace string `json:",omitempty"`
60 Revision int `json:",omitempty"`
61 Updated string `json:",omitempty"`
62 Status string `json:",omitempty"`
63 Chart string `json:",omitempty"`
64 AppVersion string `json:",omitempty"`
65 Values map[string]interface{} `json:"-"`
86 host = "postgres.default"
93 func runInstall(res http.ResponseWriter, req *http.Request) {
94 query := req.URL.Query()
95 chartName = query.Get("chart")
96 releaseName = chartName
97 fmt.Println("Installing ", chartName)
101 var install *action.Install
102 chartMuseumService, chartMuseumPort := findService("chartmuseum", "default")
103 fmt.Printf("Chart Museum service:%s, Port:%d\n", chartMuseumService, chartMuseumPort)
104 url := "http://" + chartMuseumService + ":" + fmt.Sprint(chartMuseumPort)
105 if !chartInstalled(chartName) {
107 fmt.Printf("Adding %s to Helm Repo\n", url)
108 _, err := addToRepo(url)
112 install, err = dryRun()
116 if rapp.SecurityEnabled && rapp.Type == "provider" {
117 // keycloak client setup
118 fmt.Println("Setting up keycloak")
119 _, err = http.Get("http://rapps-keycloak-mgr.default/create?realm=" + rapp.Realm + "&name=" + rapp.Client + "&role=" + rapp.Roles[0].Role)
123 fmt.Println("Setting up istio")
124 _, err := http.Get("http://rapps-istio-mgr.default/create?name=" + chartName + "&realm=" + rapp.Realm + "&role=" + rapp.Roles[0].Role + "&method=" + rapp.Roles[0].Grants[0])
129 fmt.Printf("Installing chart %s to %s namespace\n", chartName, namespace)
130 chart, err = installHelmChart(install)
132 msg = "Error occurred during installation " + err.Error()
134 msg = "Successfully installed release: " + chart
140 fmt.Printf("Installing chart %s to %s namespace\n", chartName, namespace)
141 chart, err = installHelmChart(install)
143 msg = "Error occurred during installation " + err.Error()
145 msg = "Successfully installed release: " + chart
151 registrerRapp(chartName, rapp.Type)
153 msg = chartName + " has already been installed"
156 // create response binary data
157 data := []byte(msg) // slice of bytes
158 // write `data` to response
162 func runUninstall(res http.ResponseWriter, req *http.Request) {
163 query := req.URL.Query()
164 chartName = query.Get("chart")
165 releaseName = chartName
166 fmt.Println("Uninstalling ", chartName)
170 if chartInstalled(chartName) {
171 err := getChartValues(chartName)
175 chart, err = uninstallHelmChart(chartName)
177 msg = "Error occurred during uninstall " + err.Error()
179 msg = "Successfully uninstalled release: " + chart
181 if rapp.SecurityEnabled && rapp.Type == "provider" {
182 // Remove istio objects for rapp
183 fmt.Println("Removing istio services")
184 _, err := http.Get("http://rapps-istio-mgr.default/remove?name=" + chartName)
188 // remove keycloak client
189 fmt.Println("Removing keycloak client")
190 _, err = http.Get("http://rapps-keycloak-mgr.default/remove?realm=" + rapp.Realm + "&name=" + rapp.Client + "&role=" + rapp.Roles[0].Role)
196 unregistrerRapp(chartName, rapp.Type)
198 msg = chartName + " is not installed"
201 // create response binary data
202 data := []byte(msg) // slice of bytes
203 // write `data` to response
207 func runList(res http.ResponseWriter, req *http.Request) {
209 // create response binary data
210 data, err := json.Marshal(chartInfo)
212 fmt.Printf("Error happened in JSON marshal. Err: %s\n", err)
214 // write `data` to response
219 //flag.StringVar(&url, "url", "http://chartmuseum:8080", "ChartMuseum url")
220 flag.StringVar(&repoName, "repoName", "local-dev", "Repository name")
221 flag.StringVar(&namespace, "namespace", "istio-nonrtric", "namespace for install")
225 runInstallHandler := http.HandlerFunc(runInstall)
226 http.Handle("/install", runInstallHandler)
227 runUninstallHandler := http.HandlerFunc(runUninstall)
228 http.Handle("/uninstall", runUninstallHandler)
229 runListHandler := http.HandlerFunc(runList)
230 http.Handle("/list", runListHandler)
231 http.ListenAndServe(":9000", nil)
234 func addToRepo(url string) (string, error) {
235 repoFile := settings.RepositoryConfig
237 //Ensure the file directory exists as it is required for file locking
238 err := os.MkdirAll(filepath.Dir(repoFile), os.ModePerm)
239 if err != nil && !os.IsExist(err) {
243 b, err := ioutil.ReadFile(repoFile)
244 if err != nil && !os.IsNotExist(err) {
249 if err := yaml.Unmarshal(b, &f); err != nil {
254 fmt.Printf("repository name (%s) already exists\n", repoName)
263 r, err := repo.NewChartRepository(&c, getter.All(settings))
268 if _, err := r.DownloadIndexFile(); err != nil {
269 err := errors.Wrapf(err, "looks like %q is not a valid chart repository or cannot be reached", url)
275 if err := f.WriteFile(repoFile, 0644); err != nil {
278 fmt.Printf("%q has been added to your repositories\n", repoName)
282 func dryRun() (*action.Install, error) {
283 actionConfig, err := getActionConfig(namespace)
285 install := action.NewInstall(actionConfig)
287 cp, err := install.ChartPathOptions.LocateChart(fmt.Sprintf("%s/%s", repoName, chartName), settings)
289 chartRequested, err = loader.Load(cp)
291 install.Namespace = namespace
292 install.ReleaseName = releaseName
293 install.DryRun = true
294 rel, err := install.Run(chartRequested, nil)
300 rappMap := rel.Chart.Values["rapp"]
301 // Convert map to json string
302 jsonStr, err := json.Marshal(rappMap)
308 if err := json.Unmarshal(jsonStr, &rapp); err != nil {
312 fmt.Printf("Keycloak key/value pairs in values.yaml - Realm: %s Client: %s Client Role: %s\n", rapp.Realm, rapp.Client, rapp.Roles)
316 func installHelmChart(install *action.Install) (string, error) {
318 install.DryRun = false
319 rel, err := install.Run(chartRequested, nil)
323 fmt.Println("Successfully installed release: ", rel.Name)
328 func getActionConfig(namespace string) (*action.Configuration, error) {
329 actionConfig := new(action.Configuration)
330 // Create the rest config instance with ServiceAccount values loaded in them
331 config, err := rest.InClusterConfig()
333 // fallback to kubeconfig
334 home, exists := os.LookupEnv("HOME")
338 kubeconfigPath := filepath.Join(home, ".kube", "config")
339 if envvar := os.Getenv("KUBECONFIG"); len(envvar) > 0 {
340 kubeconfigPath = envvar
342 if err := actionConfig.Init(kube.GetConfig(kubeconfigPath, "", namespace), namespace, os.Getenv("HELM_DRIVER"),
343 func(format string, v ...interface{}) {
344 fmt.Sprintf(format, v)
349 // Create the ConfigFlags struct instance with initialized values from ServiceAccount
350 var kubeConfig *genericclioptions.ConfigFlags
351 kubeConfig = genericclioptions.NewConfigFlags(false)
352 kubeConfig.APIServer = &config.Host
353 kubeConfig.BearerToken = &config.BearerToken
354 kubeConfig.CAFile = &config.CAFile
355 kubeConfig.Namespace = &namespace
356 if err := actionConfig.Init(kubeConfig, namespace, os.Getenv("HELM_DRIVER"), func(format string, v ...interface{}) {
357 fmt.Sprintf(format, v)
362 return actionConfig, err
365 func uninstallHelmChart(name string) (string, error) {
366 actionConfig, err := getActionConfig(namespace)
371 iCli := action.NewUninstall(actionConfig)
373 resp, err := iCli.Run(name)
377 fmt.Println("Successfully uninstalled release: ", resp.Release.Name)
378 return resp.Release.Name, err
381 func connectToK8s() *kubernetes.Clientset {
382 config, err := rest.InClusterConfig()
384 fmt.Println("failed to create K8s config")
387 clientset, err := kubernetes.NewForConfig(config)
389 fmt.Println("Failed to create K8s clientset")
395 func findService(serviceName, namespace string) (string, int32) {
396 clientset := connectToK8s()
397 svc, err := clientset.CoreV1().Services(namespace).Get(context.TODO(), serviceName, metav1.GetOptions{})
399 fmt.Println(err.Error())
401 return svc.Name, svc.Spec.Ports[0].Port
404 func list() []ChartInfo {
405 var charts = []ChartInfo{}
407 actionConfig, err := getActionConfig(namespace)
412 listAction := action.NewList(actionConfig)
413 releases, err := listAction.Run()
417 for _, release := range releases {
418 //fmt.Println("Release: " + release.Name + " Status: " + release.Info.Status.String())
419 chart.Name = release.Name
420 chart.Namespace = release.Namespace
421 chart.Revision = release.Version
422 chart.Updated = release.Info.LastDeployed.String()
423 chart.Status = release.Info.Status.String()
424 chart.Chart = release.Chart.Metadata.Name + "-" + release.Chart.Metadata.Version
425 chart.AppVersion = release.Chart.Metadata.AppVersion
426 chart.Values = release.Chart.Values
427 charts = append(charts, chart)
432 func chartInstalled(chartName string) bool {
434 for _, chart := range charts {
435 if chart.Name == chartName {
442 func getChartValues(chartName string) error {
444 for _, chart := range charts {
445 if chart.Name == chartName {
446 rappMap := chart.Values["rapp"]
447 fmt.Println("rappMap:", rappMap)
448 // Convert map to json string
449 jsonStr, err := json.Marshal(rappMap)
451 fmt.Println("Error:", err)
455 if err := json.Unmarshal(jsonStr, &rapp); err != nil {
456 fmt.Println("Error:", err)
462 return errors.New("Chart: cannot retrieve values")
465 func registrerRapp(chartName, chartType string) {
466 psqlconn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", host, port, user, password, dbname)
468 db, err := sql.Open("postgres", psqlconn)
472 fmt.Println("Connected!")
479 createStmt := `CREATE TABLE IF NOT EXISTS services (
480 id serial PRIMARY KEY,
481 name VARCHAR ( 50 ) UNIQUE NOT NULL,
482 type VARCHAR ( 50 ) NOT NULL,
483 created_on TIMESTAMP DEFAULT NOW()
485 _, err = db.Exec(createStmt)
489 fmt.Println("Created table for service registry")
493 insertDynStmt := `insert into "services"("name", "type") values($1, $2)`
494 _, err = db.Exec(insertDynStmt, chartName, chartType)
498 fmt.Println("Inserted " + chartName + " into service registry")
502 func unregistrerRapp(chartName, chartType string) {
503 psqlconn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", host, port, user, password, dbname)
505 db, err := sql.Open("postgres", psqlconn)
509 fmt.Println("Connected!")
515 deleteDynStmt := `delete from services where name=$1 and type=$2`
516 _, err = db.Exec(deleteDynStmt, chartName, chartType)
520 fmt.Println("Deleted " + chartName + " from service registry")