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===================================
28 "github.com/pkg/errors"
30 "helm.sh/helm/v3/pkg/action"
31 "helm.sh/helm/v3/pkg/chart"
32 "helm.sh/helm/v3/pkg/chart/loader"
33 "helm.sh/helm/v3/pkg/cli"
34 "helm.sh/helm/v3/pkg/getter"
35 "helm.sh/helm/v3/pkg/kube"
36 "helm.sh/helm/v3/pkg/repo"
38 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
39 "k8s.io/cli-runtime/pkg/genericclioptions"
40 kubernetes "k8s.io/client-go/kubernetes"
41 "k8s.io/client-go/rest"
47 var settings *cli.EnvSettings
48 var chartRequested *chart.Chart
53 var releaseName string
56 type ChartInfo struct {
57 Name string `json:",omitempty"`
58 Namespace string `json:",omitempty"`
59 Revision int `json:",omitempty"`
60 Updated string `json:",omitempty"`
61 Status string `json:",omitempty"`
62 Chart string `json:",omitempty"`
63 AppVersion string `json:",omitempty"`
64 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 err := installSecurity(rapp)
120 fmt.Printf("Installing chart %s to %s namespace\n", chartName, namespace)
121 chart, err = installHelmChart(install)
123 msg = "Error occurred during installation " + err.Error()
125 msg = "Successfully installed release: " + chart
131 registrerRapp(chartName, rapp.Type)
133 msg = chartName + " has already been installed"
136 // create response binary data
137 data := []byte(msg) // slice of bytes
138 // write `data` to response
142 func installSecurity(rapp Rapp) error {
145 role := rapp.Roles[0].Role
146 grants := rapp.Roles[0].Grants[0]
148 client := rapp.Client
149 authenticator := rapp.Authenticator
151 if !rapp.SecurityEnabled {
154 // Different security requirements depending on the rapp type
155 if rapp.Type == "provider" {
156 // keycloak client setup
157 fmt.Println("Setting up keycloak")
158 url = "http://rapps-keycloak-mgr.default/create?"
159 params = "realm=" + realm + "&name=" + client + "&role=" + role + "&authType=" + authenticator
161 _, err := http.Get(url)
165 fmt.Println("Setting up istio")
166 url = "http://rapps-istio-mgr.default/create-policy?"
167 params = "name=" + chartName + "&realm=" + realm + "&role=" + role + "&method=" + grants
170 _, err := http.Get(url)
176 fmt.Println("Setting up istio")
177 url = "http://rapps-istio-mgr.default/create-filter?"
178 params = "name=" + chartName + "&realm=" + realm + "&client=" + client + "&authType=" + authenticator
180 _, err := http.Get(url)
190 func runUninstall(res http.ResponseWriter, req *http.Request) {
191 query := req.URL.Query()
192 chartName = query.Get("chart")
193 releaseName = chartName
194 fmt.Println("Uninstalling ", chartName)
198 if chartInstalled(chartName) {
199 err := getChartValues(chartName)
203 chart, err = uninstallHelmChart(chartName)
205 msg = "Error occurred during uninstall " + err.Error()
207 msg = "Successfully uninstalled release: " + chart
209 err := uninstallSecurity(rapp, chartName)
214 unregistrerRapp(chartName, rapp.Type)
216 msg = chartName + " is not installed"
219 // create response binary data
220 data := []byte(msg) // slice of bytes
221 // write `data` to response
225 func uninstallSecurity(rapp Rapp, chartName string) error {
228 role := rapp.Roles[0].Role
230 client := rapp.Client
231 authenticator := rapp.Authenticator
233 if !rapp.SecurityEnabled {
236 if rapp.Type == "provider" {
237 // Remove istio objects for rapp
238 fmt.Println("Removing istio services")
239 _, err := http.Get("http://rapps-istio-mgr.default/remove-policy?name=" + chartName)
243 // remove keycloak client
244 fmt.Println("Removing keycloak client")
245 url = "http://rapps-keycloak-mgr.default/remove?"
246 params = "name=" + client + "&realm=" + realm + "&role=" + role + "&authType=" + authenticator
248 _, err = http.Get(url)
253 if rapp.Type == "invoker" {
254 // Remove istio objects for rapp
255 fmt.Println("Removing istio services")
256 _, err := http.Get("http://rapps-istio-mgr.default/remove-filter?name=" + chartName)
264 func runList(res http.ResponseWriter, req *http.Request) {
266 // create response binary data
267 data, err := json.Marshal(chartInfo)
269 fmt.Printf("Error happened in JSON marshal. Err: %s\n", err)
271 // write `data` to response
276 //flag.StringVar(&url, "url", "http://chartmuseum:8080", "ChartMuseum url")
277 flag.StringVar(&repoName, "repoName", "local-dev", "Repository name")
278 flag.StringVar(&namespace, "namespace", "istio-nonrtric", "namespace for install")
282 runInstallHandler := http.HandlerFunc(runInstall)
283 http.Handle("/install", runInstallHandler)
284 runUninstallHandler := http.HandlerFunc(runUninstall)
285 http.Handle("/uninstall", runUninstallHandler)
286 runListHandler := http.HandlerFunc(runList)
287 http.Handle("/list", runListHandler)
288 http.ListenAndServe(":9000", nil)
291 func addToRepo(url string) (string, error) {
292 repoFile := settings.RepositoryConfig
293 fmt.Printf("Repo File %s\n", repoFile)
295 //Ensure the file directory exists as it is required for file locking
296 err := os.MkdirAll(filepath.Dir(repoFile), os.ModePerm)
297 if err != nil && !os.IsExist(err) {
301 b, err := ioutil.ReadFile(repoFile)
302 if err != nil && !os.IsNotExist(err) {
307 if err := yaml.Unmarshal(b, &f); err != nil {
312 fmt.Printf("repository name (%s) already exists\n", repoName)
321 r, err := repo.NewChartRepository(&c, getter.All(settings))
326 if _, err := r.DownloadIndexFile(); err != nil {
327 err := errors.Wrapf(err, "looks like %q is not a valid chart repository or cannot be reached", url)
333 if err := f.WriteFile(repoFile, 0644); err != nil {
336 fmt.Printf("%q has been added to your repositories\n", repoName)
340 func dryRun() (*action.Install, error) {
341 actionConfig, err := getActionConfig(namespace)
343 install := action.NewInstall(actionConfig)
345 fmt.Printf("Repo Name: %s\n",repoName)
346 fmt.Printf("Chart Name: %s\n",chartName)
347 cp, err := install.ChartPathOptions.LocateChart(fmt.Sprintf("%s/%s", repoName, chartName), settings)
348 fmt.Printf("Chart location: %s\n",cp)
350 chartRequested, err = loader.Load(cp)
352 install.Namespace = namespace
353 install.ReleaseName = releaseName
354 install.DryRun = true
355 rel, err := install.Run(chartRequested, nil)
361 rappMap := rel.Chart.Values["rapp"]
362 // Convert map to json string
363 jsonStr, err := json.Marshal(rappMap)
369 if err := json.Unmarshal(jsonStr, &rapp); err != nil {
373 fmt.Printf("Keycloak key/value pairs in values.yaml - Realm: %s Client: %s Client Role: %s\n", rapp.Realm, rapp.Client, rapp.Roles)
377 func installHelmChart(install *action.Install) (string, error) {
379 install.DryRun = false
380 rel, err := install.Run(chartRequested, nil)
384 fmt.Println("Successfully installed release: ", rel.Name)
389 func getActionConfig(namespace string) (*action.Configuration, error) {
390 actionConfig := new(action.Configuration)
391 // Create the rest config instance with ServiceAccount values loaded in them
392 config, err := rest.InClusterConfig()
394 // fallback to kubeconfig
395 home, exists := os.LookupEnv("HOME")
399 kubeconfigPath := filepath.Join(home, ".kube", "config")
400 if envvar := os.Getenv("KUBECONFIG"); len(envvar) > 0 {
401 kubeconfigPath = envvar
403 if err := actionConfig.Init(kube.GetConfig(kubeconfigPath, "", namespace), namespace, os.Getenv("HELM_DRIVER"),
404 func(format string, v ...interface{}) {
405 fmt.Sprintf(format, v)
410 // Create the ConfigFlags struct instance with initialized values from ServiceAccount
411 var kubeConfig *genericclioptions.ConfigFlags
412 kubeConfig = genericclioptions.NewConfigFlags(false)
413 kubeConfig.APIServer = &config.Host
414 kubeConfig.BearerToken = &config.BearerToken
415 kubeConfig.CAFile = &config.CAFile
416 kubeConfig.Namespace = &namespace
417 if err := actionConfig.Init(kubeConfig, namespace, os.Getenv("HELM_DRIVER"), func(format string, v ...interface{}) {
418 fmt.Sprintf(format, v)
423 return actionConfig, err
426 func uninstallHelmChart(name string) (string, error) {
427 actionConfig, err := getActionConfig(namespace)
432 iCli := action.NewUninstall(actionConfig)
434 resp, err := iCli.Run(name)
438 fmt.Println("Successfully uninstalled release: ", resp.Release.Name)
439 return resp.Release.Name, err
442 func connectToK8s() *kubernetes.Clientset {
443 config, err := rest.InClusterConfig()
445 fmt.Println("failed to create K8s config")
448 clientset, err := kubernetes.NewForConfig(config)
450 fmt.Println("Failed to create K8s clientset")
456 func findService(serviceName, namespace string) (string, int32) {
457 clientset := connectToK8s()
458 svc, err := clientset.CoreV1().Services(namespace).Get(context.TODO(), serviceName, metav1.GetOptions{})
460 fmt.Println(err.Error())
462 return svc.Name, svc.Spec.Ports[0].Port
465 func list() []ChartInfo {
466 var charts = []ChartInfo{}
468 actionConfig, err := getActionConfig(namespace)
473 listAction := action.NewList(actionConfig)
474 releases, err := listAction.Run()
478 for _, release := range releases {
479 //fmt.Println("Release: " + release.Name + " Status: " + release.Info.Status.String())
480 chart.Name = release.Name
481 chart.Namespace = release.Namespace
482 chart.Revision = release.Version
483 chart.Updated = release.Info.LastDeployed.String()
484 chart.Status = release.Info.Status.String()
485 chart.Chart = release.Chart.Metadata.Name + "-" + release.Chart.Metadata.Version
486 chart.AppVersion = release.Chart.Metadata.AppVersion
487 chart.Values = release.Chart.Values
488 charts = append(charts, chart)
493 func chartInstalled(chartName string) bool {
495 for _, chart := range charts {
496 if chart.Name == chartName {
503 func getChartValues(chartName string) error {
505 for _, chart := range charts {
506 if chart.Name == chartName {
507 rappMap := chart.Values["rapp"]
508 fmt.Println("rappMap:", rappMap)
509 // Convert map to json string
510 jsonStr, err := json.Marshal(rappMap)
512 fmt.Println("Error:", err)
516 if err := json.Unmarshal(jsonStr, &rapp); err != nil {
517 fmt.Println("Error:", err)
523 return errors.New("Chart: cannot retrieve values")
526 func registrerRapp(chartName, chartType string) {
527 psqlconn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", host, port, user, password, dbname)
529 db, err := sql.Open("postgres", psqlconn)
533 fmt.Println("Connected!")
540 createStmt := `CREATE TABLE IF NOT EXISTS services (
541 id serial PRIMARY KEY,
542 name VARCHAR ( 50 ) UNIQUE NOT NULL,
543 type VARCHAR ( 50 ) NOT NULL,
544 created_on TIMESTAMP DEFAULT NOW()
546 _, err = db.Exec(createStmt)
550 fmt.Println("Created table for service registry")
554 insertDynStmt := `insert into "services"("name", "type") values($1, $2)`
555 _, err = db.Exec(insertDynStmt, chartName, chartType)
559 fmt.Println("Inserted " + chartName + " into service registry")
563 func unregistrerRapp(chartName, chartType string) {
564 psqlconn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", host, port, user, password, dbname)
566 db, err := sql.Open("postgres", psqlconn)
570 fmt.Println("Connected!")
576 deleteDynStmt := `delete from services where name=$1 and type=$2`
577 _, err = db.Exec(deleteDynStmt, chartName, chartType)
581 fmt.Println("Deleted " + chartName + " from service registry")