Implement api as rundeck option provider

- Use rundeck's name value list format
https://docs.rundeck.com/docs/manual/job-options.html#option-model-provider
- Use selected param as query string to select by default the returns
values
- Multi groups selection separated by comma
- Return 200 response code for empty host

ref https://github.com/peopledoc/peopleinfra/issues/8328

Author: Nicolas Sterchele

api/handlers/check.go

@@ -0,0 +1,27 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type checkHandler struct {
+	*log.Logger
+}
+
+func (cH checkHandler) check(w http.ResponseWriter, r *http.Request) {
+	log.Trace("health path called")
+	okResp := map[string]bool{"ok": true}
+
+	js, err := json.Marshal(okResp)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.Write(js)
+	return
+}

api/handlers/groups.go

@@ -0,0 +1,62 @@
+package handlers
+
+import (
+	"encoding/json"
+	"io"
+	"jarvis/internal/pkg/ansible"
+	"jarvis/internal/pkg/environment"
+	"net/http"
+	"path"
+
+	"github.com/gorilla/mux"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/viper"
+)
+
+type groupsHandler struct {
+	*log.Logger
+}
+
+func (gH groupsHandler) list(w http.ResponseWriter, r *http.Request) {
+	log.Trace("hosts path called")
+	vars := mux.Vars(r)
+	helperPath := path.Join(
+		viper.GetString("environments.path"), viper.GetString("environments.helper"))
+
+	//env, group
+	if rawEnv, ok := vars["env"]; ok {
+		env, err := environment.ParseRawEnvironmentPredicate(helperPath, rawEnv)
+		if err != nil {
+			logErrorToResponse(err, "groups", w)
+			return
+		}
+		envs := []*environment.Environment{env}
+		invReaders, err := inventoriesReaders(envs)
+		if err != nil {
+			logErrorToResponse(err, "groups", w)
+			return
+		}
+		r := io.MultiReader(invReaders...)
+		manipulator, err := ansible.InitInventoryManipulator(r)
+		if err != nil {
+			logErrorToResponse(err, "groups", w)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+
+		groups, err := manipulator.GetGroupsName(false)
+		if err != nil {
+			logErrorToResponse(err, "groups", w)
+			return
+		}
+
+		js, err := json.Marshal(groups)
+		if err != nil {
+			logErrorToResponse(err, "groups", w)
+			return
+		}
+
+		w.Write(js)
+		return
+	}
+}

api/handlers/handlers.go

@@ -0,0 +1,70 @@
+package handlers
+
+import (
+	"io"
+	"jarvis/internal/pkg/ansible"
+	"jarvis/internal/pkg/environment"
+	"net/http"
+
+	"github.com/gorilla/mux"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/viper"
+)
+
+func API(log *log.Logger) http.Handler {
+	router := mux.NewRouter().StrictSlash(true)
+
+	//check (health)
+	cH := checkHandler{log}
+	router.HandleFunc("/health", cH.check).
+		Methods("GET")
+
+	//playbooks
+	pH := playbookHandler{log}
+	router.HandleFunc("/playbooks", pH.list).
+		Methods("GET")
+
+	//platforms
+	ptH := platformsHandler{log}
+	router.HandleFunc("/platforms/{env}", ptH.list).
+		Methods("GET")
+
+	//groups
+	gH := groupsHandler{log}
+	router.HandleFunc("/groups/{env}", gH.list).
+		Methods("GET")
+
+	//hosts
+	hH := hostsHandler{log}
+	router.HandleFunc("/hosts/{env}/", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNoContent)
+	}).
+		Methods("GET")
+	router.HandleFunc("/hosts/{env}/{groups}", hH.list).
+		Methods("GET")
+
+	return router
+}
+
+func logErrorToResponse(err error, handler string, w http.ResponseWriter) {
+	http.Error(w, err.Error(), http.StatusInternalServerError)
+	log.WithFields(log.Fields{
+		"handler": handler,
+	}).Error(err.Error())
+}
+
+func inventoriesReaders(envs []*environment.Environment) ([]io.Reader, error) {
+	envsPath := viper.GetString("environments.path")
+
+	allInventories, err := environment.GetFullPathInventoriesFromEnvironments(envsPath, envs)
+	if err != nil {
+		return nil, err
+	}
+
+	invReaders, err := ansible.BuildReadersFromInventoriesPath(allInventories)
+	if err != nil {
+		return nil, err
+	}
+
+	return invReaders, nil
+}

api/handlers/hosts.go

@@ -0,0 +1,80 @@
+package handlers
+
+import (
+	"encoding/json"
+	"io"
+	"jarvis/internal/pkg/ansible"
+	"jarvis/internal/pkg/environment"
+	"net/http"
+	"path"
+	"strconv"
+	"strings"
+
+	"github.com/gorilla/mux"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/viper"
+)
+
+type hostsHandler struct {
+	*log.Logger
+}
+
+func (hH hostsHandler) list(w http.ResponseWriter, r *http.Request) {
+	log.Trace("hosts path called")
+	vars := mux.Vars(r)
+	helperPath := path.Join(
+		viper.GetString("environments.path"), viper.GetString("environments.helper"))
+
+	//lets return selected at true by default
+	selectedRaw, selectedInQuery := r.URL.Query()["selected"]
+	selected := true
+	if selectedInQuery && len(selectedRaw) > 0 {
+		//don't care of multiple `selected` query parameter
+		if s, err := strconv.ParseBool(selectedRaw[0]); err == nil {
+			selected = s
+		}
+	}
+
+	//env, group
+	if rawEnv, ok := vars["env"]; ok {
+		env, err := environment.ParseRawEnvironmentPredicate(helperPath, rawEnv)
+		if err != nil {
+			logErrorToResponse(err, "hosts", w)
+			return
+		}
+		envs := []*environment.Environment{env}
+		invReaders, err := inventoriesReaders(envs)
+		if err != nil {
+			logErrorToResponse(err, "hosts", w)
+			return
+		}
+		r := io.MultiReader(invReaders...)
+		manipulator, err := ansible.InitInventoryManipulator(r)
+		if err != nil {
+			logErrorToResponse(err, "hosts", w)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+
+		if rawGroups, ok := vars["groups"]; ok {
+			groups := strings.Split(rawGroups, ",")
+			var hosts []string
+			for _, group := range groups {
+				h, err := manipulator.GetHostsByGroupName(group)
+				hosts = append(hosts, h...)
+				if err != nil {
+					logErrorToResponse(err, "hosts", w)
+					return
+				}
+			}
+			js, err := json.Marshal(fillRundeckResult(hosts, selected))
+			if err != nil {
+				logErrorToResponse(err, "hosts", w)
+				return
+			}
+
+			w.Write(js)
+			return
+		}
+	}
+}

api/handlers/platforms.go

@@ -0,0 +1,33 @@
+package handlers
+
+import (
+	"jarvis/internal/pkg/environment"
+	"net/http"
+	"path"
+
+	"github.com/gorilla/mux"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/viper"
+)
+
+type platformsHandler struct {
+	*log.Logger
+}
+
+func (pH platformsHandler) list(w http.ResponseWriter, r *http.Request) {
+	log.Trace("platforms path called")
+	helperPath := path.Join(
+		viper.GetString("environments.path"), viper.GetString("environments.helper"))
+	vars := mux.Vars(r)
+
+	env, err := environment.ParseRawEnvironmentPredicate(helperPath, vars["env"])
+	if err != nil {
+		logErrorToResponse(err, "platforms", w)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	printer := environment.JsonPrinter{}
+	printer.PrintEnvironments(w, []*environment.Environment{env})
+}

api/handlers/playbooks.go

@@ -0,0 +1,33 @@
+package handlers
+
+import (
+	"encoding/json"
+	"jarvis/internal/pkg/ansible"
+	"net/http"
+
+	"github.com/spf13/viper"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type playbookHandler struct {
+	*log.Logger
+}
+
+func (pH playbookHandler) list(w http.ResponseWriter, r *http.Request) {
+	pH.Trace("playbooks path called")
+	pBookPath := viper.GetString("ansible.playbook.playbooks_path")
+	pbooks, err := ansible.ListPlaybooks(pBookPath)
+	if err != nil {
+		logErrorToResponse(err, "playbook", w)
+		return
+	}
+	js, err := json.Marshal(pbooks)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.Write(js)
+}

api/handlers/rundeck.go

@@ -0,0 +1,17 @@
+package handlers
+
+type rundeckResult struct {
+	Name     string `json:"name"`
+	Value    string `json:"value"`
+	Selected bool   `json:"selected"`
+}
+
+func fillRundeckResult(results []string, selected bool) []rundeckResult {
+	var rundeckR []rundeckResult
+	rundeckR = make([]rundeckResult, len(results), len(results))
+	for i, r := range results {
+		rundeckR[i] = rundeckResult{r, r, selected}
+	}
+
+	return rundeckR
+}

api/main.go

@@ -0,0 +1,35 @@
+package api
+
+import (
+	"fmt"
+	"jarvis/api/handlers"
+	"net/http"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type Api struct {
+	logger *log.Logger
+	port   int
+}
+
+func InitApi(logger *log.Logger, port int) *Api {
+	return &Api{logger, port}
+}
+
+func (api *Api) Run() error {
+	var httpSrv *http.Server
+
+	h := handlers.API(api.logger)
+	httpSrv = &http.Server{
+		ReadTimeout:  5 * time.Second,
+		WriteTimeout: 5 * time.Second,
+		Handler:      h,
+		Addr:         fmt.Sprintf(":%d", api.port),
+	}
+
+	err := httpSrv.ListenAndServe()
+
+	return err
+}