runners ui

.gitignore

@@ -7,6 +7,8 @@ web/public/fonts/*.*
 web/.nyc_output
 api/public/**/*
 /config.json
+/config-runner.json
+/config-runner-token.txt
 /.dredd/config.json
 /database.boltdb
 /database.boltdb.lock
@@ -29,3 +31,4 @@ node_modules/
 .vscode
 __debug_bin*
 .task/
+/web/.env

api/apps.go

@@ -215,6 +215,7 @@ func setAppActive(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if !helpers.Bind(w, r, &body) {
+		helpers.WriteErrorStatus(w, "Invalid request body", http.StatusBadRequest)
 		return
 	}
 

api/router.go

@@ -80,18 +80,20 @@ func Route() *mux.Router {
 	publicAPIRouter := r.PathPrefix(webPath + "api").Subrouter()
 	publicAPIRouter.Use(StoreMiddleware, JSONMiddleware)
 
-	publicAPIRouter.HandleFunc("/runners", runners.RegisterRunner).Methods("POST")
 	publicAPIRouter.HandleFunc("/auth/login", login).Methods("GET", "POST")
 	publicAPIRouter.HandleFunc("/auth/logout", logout).Methods("POST")
 	publicAPIRouter.HandleFunc("/auth/oidc/{provider}/login", oidcLogin).Methods("GET")
 	publicAPIRouter.HandleFunc("/auth/oidc/{provider}/redirect", oidcRedirect).Methods("GET")
 	publicAPIRouter.HandleFunc("/auth/oidc/{provider}/redirect/{redirect_path:.*}", oidcRedirect).Methods("GET")
 
-	routersAPI := r.PathPrefix(webPath + "api").Subrouter()
-	routersAPI.Use(StoreMiddleware, JSONMiddleware, runners.RunnerMiddleware)
-	routersAPI.Path("/runners/{runner_id}").HandlerFunc(runners.GetRunner).Methods("GET", "HEAD")
-	routersAPI.Path("/runners/{runner_id}").HandlerFunc(runners.UpdateRunner).Methods("PUT")
-	routersAPI.Path("/runners/{runner_id}").HandlerFunc(runners.UnregisterRunner).Methods("DELETE")
+	internalAPI := publicAPIRouter.PathPrefix("/internal").Subrouter()
+	internalAPI.HandleFunc("/runners", runners.RegisterRunner).Methods("POST")
+
+	runnersAPI := internalAPI.PathPrefix("/runners").Subrouter()
+	runnersAPI.Use(runners.RunnerMiddleware)
+	runnersAPI.Path("").HandlerFunc(runners.GetRunner).Methods("GET", "HEAD")
+	runnersAPI.Path("").HandlerFunc(runners.UpdateRunner).Methods("PUT")
+	runnersAPI.Path("").HandlerFunc(runners.UnregisterRunner).Methods("DELETE")
 
 	publicWebHookRouter := r.PathPrefix(webPath + "api").Subrouter()
 	publicWebHookRouter.Use(StoreMiddleware, JSONMiddleware)
@@ -128,6 +130,16 @@ func Route() *mux.Router {
 	adminAPI.Path("/options").HandlerFunc(getOptions).Methods("GET", "HEAD")
 	adminAPI.Path("/options").HandlerFunc(setOption).Methods("POST")
 
+	adminAPI.Path("/runners").HandlerFunc(getGlobalRunners).Methods("GET", "HEAD")
+	adminAPI.Path("/runners").HandlerFunc(addGlobalRunner).Methods("POST", "HEAD")
+
+	globalRunnersAPI := adminAPI.PathPrefix("/runners").Subrouter()
+	globalRunnersAPI.Use(globalRunnerMiddleware)
+	globalRunnersAPI.Path("/{runner_id}").HandlerFunc(getGlobalRunner).Methods("GET", "HEAD")
+	globalRunnersAPI.Path("/{runner_id}").HandlerFunc(updateGlobalRunner).Methods("PUT", "POST")
+	globalRunnersAPI.Path("/{runner_id}/active").HandlerFunc(setGlobalRunnerActive).Methods("POST")
+	globalRunnersAPI.Path("/{runner_id}").HandlerFunc(deleteGlobalRunner).Methods("DELETE")
+
 	appsAPI := adminAPI.PathPrefix("/apps").Subrouter()
 	appsAPI.Use(appMiddleware)
 	appsAPI.Path("/{app_id}").HandlerFunc(getApp).Methods("GET", "HEAD")
@@ -446,8 +458,10 @@ func serveFile(w http.ResponseWriter, r *http.Request, name string) {
 
 func getSystemInfo(w http.ResponseWriter, r *http.Request) {
 	body := map[string]interface{}{
-		"version": util.Version(),
-		"ansible": util.AnsibleVersion(),
+		"version":           util.Version(),
+		"ansible":           util.AnsibleVersion(),
+		"web_host":          util.WebHostURL.String(),
+		"use_remote_runner": util.Config.UseRemoteRunner,
 	}
 
 	helpers.WriteJSON(w, http.StatusOK, body)

api/runners.go

@@ -0,0 +1,157 @@
+package api
+
+import (
+	"github.com/ansible-semaphore/semaphore/api/helpers"
+	"github.com/ansible-semaphore/semaphore/db"
+	log "github.com/sirupsen/logrus"
+	"net/http"
+
+	"github.com/gorilla/context"
+)
+
+//type minimalGlobalRunner struct {
+//	ID               int    `json:"id"`
+//	Name             string `json:"name"`
+//	Active           bool   `json:"active"`
+//	Webhook          string `db:"webhook" json:"webhook"`
+//	MaxParallelTasks int    `db:"max_parallel_tasks" json:"max_parallel_tasks"`
+//}
+
+func getGlobalRunners(w http.ResponseWriter, r *http.Request) {
+	runners, err := helpers.Store(r).GetGlobalRunners(false)
+
+	if err != nil {
+		panic(err)
+	}
+
+	var result = make([]db.Runner, 0)
+
+	for _, runner := range runners {
+		result = append(result, runner)
+	}
+
+	helpers.WriteJSON(w, http.StatusOK, result)
+}
+
+type runnerWithToken struct {
+	db.Runner
+	Token string `json:"token"`
+}
+
+func addGlobalRunner(w http.ResponseWriter, r *http.Request) {
+	var runner db.Runner
+	if !helpers.Bind(w, r, &runner) {
+		return
+	}
+
+	runner.ProjectID = nil
+	newRunner, err := helpers.Store(r).CreateRunner(runner)
+
+	if err != nil {
+		log.Warn("Runner is not created: " + err.Error())
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	helpers.WriteJSON(w, http.StatusCreated, runnerWithToken{
+		Runner: newRunner,
+		Token:  newRunner.Token,
+	})
+}
+
+func globalRunnerMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		runnerID, err := helpers.GetIntParam("runner_id", w, r)
+
+		if err != nil {
+			helpers.WriteJSON(w, http.StatusBadRequest, map[string]string{
+				"error": "runner_id required",
+			})
+			return
+		}
+
+		store := helpers.Store(r)
+
+		runner, err := store.GetGlobalRunner(runnerID)
+
+		if err != nil {
+			helpers.WriteJSON(w, http.StatusNotFound, map[string]string{
+				"error": "Runner not found",
+			})
+			return
+		}
+
+		context.Set(r, "runner", &runner)
+		next.ServeHTTP(w, r)
+	})
+}
+
+func getGlobalRunner(w http.ResponseWriter, r *http.Request) {
+	runner := context.Get(r, "runner").(*db.Runner)
+
+	helpers.WriteJSON(w, http.StatusOK, runner)
+}
+
+func updateGlobalRunner(w http.ResponseWriter, r *http.Request) {
+	oldRunner := context.Get(r, "runner").(*db.Runner)
+
+	var runner db.Runner
+	if !helpers.Bind(w, r, &runner) {
+		return
+	}
+
+	store := helpers.Store(r)
+
+	runner.ID = oldRunner.ID
+	runner.ProjectID = nil
+
+	err := store.UpdateRunner(runner)
+
+	if err != nil {
+		helpers.WriteErrorStatus(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func deleteGlobalRunner(w http.ResponseWriter, r *http.Request) {
+	runner := context.Get(r, "runner").(*db.Runner)
+
+	store := helpers.Store(r)
+
+	err := store.DeleteGlobalRunner(runner.ID)
+
+	if err != nil {
+		helpers.WriteErrorStatus(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func setGlobalRunnerActive(w http.ResponseWriter, r *http.Request) {
+	runner := context.Get(r, "runner").(*db.Runner)
+
+	store := helpers.Store(r)
+
+	var body struct {
+		Active bool `json:"active"`
+	}
+
+	if !helpers.Bind(w, r, &body) {
+		helpers.WriteErrorStatus(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	runner.Active = body.Active
+
+	err := store.UpdateRunner(*runner)
+
+	if err != nil {
+		helpers.WriteErrorStatus(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	w.WriteHeader(http.StatusNoContent)
+}

api/runners/runners.go

@@ -14,7 +14,7 @@ import (
 func RunnerMiddleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 
-		token := r.Header.Get("X-API-Token")
+		token := r.Header.Get("X-Runner-Token")
 
 		if token == "" {
 			helpers.WriteJSON(w, http.StatusUnauthorized, map[string]string{
@@ -23,18 +23,9 @@ func RunnerMiddleware(next http.Handler) http.Handler {
 			return
 		}
 
-		runnerID, err := helpers.GetIntParam("runner_id", w, r)
-
-		if err != nil {
-			helpers.WriteJSON(w, http.StatusBadRequest, map[string]string{
-				"error": "runner_id required",
-			})
-			return
-		}
-
 		store := helpers.Store(r)
 
-		runner, err := store.GetGlobalRunner(runnerID)
+		runner, err := store.GetGlobalRunnerByToken(token)
 
 		if err != nil {
 			helpers.WriteJSON(w, http.StatusNotFound, map[string]string{
@@ -199,11 +190,12 @@ func RegisterRunner(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	res := util.RunnerConfig{
-		RunnerID: runner.ID,
-		Token:    runner.Token,
+	var res struct {
+		Token string `json:"token"`
 	}
 
+	res.Token = runner.Token
+
 	helpers.WriteJSON(w, http.StatusOK, res)
 }
 

cli/cmd/root.go

@@ -19,6 +19,7 @@ import (
 )
 
 var configPath string
+var noConfig bool
 
 var rootCmd = &cobra.Command{
 	Use:   "semaphore",
@@ -34,8 +35,9 @@ Complete documentation is available at https://ansible-semaphore.com.`,
 
 func Execute() {
 	rootCmd.PersistentFlags().StringVar(&configPath, "config", "", "Configuration file path")
+	rootCmd.PersistentFlags().BoolVar(&noConfig, "no-config", false, "Don't use configuration file")
 	if err := rootCmd.Execute(); err != nil {
-		fmt.Fprintln(os.Stderr, err)
+		_, _ = fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)
 	}
 }
@@ -96,7 +98,7 @@ func runService() {
 }
 
 func createStore(token string) db.Store {
-	util.ConfigInit(configPath)
+	util.ConfigInit(configPath, noConfig)
 
 	store := factory.CreateStore()
 

cli/cmd/runner_start.go

@@ -11,7 +11,7 @@ func init() {
 }
 
 func runRunner() {
-	util.ConfigInit(configPath)
+	util.ConfigInit(configPath, noConfig)
 
 	taskPool := runners.JobPool{}
 

cli/cmd/runner_unregister.go

@@ -11,7 +11,7 @@ func init() {
 }
 
 func unregisterRunner() {
-	util.ConfigInit(configPath)
+	util.ConfigInit(configPath, noConfig)
 
 	taskPool := runners.JobPool{}
 	err := taskPool.Unregister()

cli/cmd/setup.go

@@ -33,7 +33,7 @@ func doSetup() int {
 
 	configPath := setup.SaveConfig(config)
 
-	util.ConfigInit(configPath)
+	util.ConfigInit(configPath, false)
 
 	fmt.Println(" Pinging db..")
 

db/Migration.go

@@ -71,6 +71,7 @@ func GetMigrations() []Migration {
 		{Version: "2.10.12"},
 		{Version: "2.10.15"},
 		{Version: "2.10.16"},
+		{Version: "2.10.26"},
 	}
 }
 

db/Runner.go

@@ -8,10 +8,12 @@ type RunnerState string
 //)
 
 type Runner struct {
-	ID        int    `db:"id" json:"-"`
+	ID        int    `db:"id" json:"id"`
 	Token     string `db:"token" json:"-"`
 	ProjectID *int   `db:"project_id" json:"project_id"`
 	//State            RunnerState `db:"state" json:"state"`
 	Webhook          string `db:"webhook" json:"webhook"`
 	MaxParallelTasks int    `db:"max_parallel_tasks" json:"max_parallel_tasks"`
+	Active           bool   `db:"active" json:"active"`
+	Name             string `db:"name" json:"name"`
 }

db/Store.go

@@ -256,8 +256,9 @@ type Store interface {
 	GetRunner(projectID int, runnerID int) (Runner, error)
 	GetRunners(projectID int) ([]Runner, error)
 	DeleteRunner(projectID int, runnerID int) error
+	GetGlobalRunnerByToken(token string) (Runner, error)
 	GetGlobalRunner(runnerID int) (Runner, error)
-	GetGlobalRunners() ([]Runner, error)
+	GetGlobalRunners(activeOnly bool) ([]Runner, error)
 	DeleteGlobalRunner(runnerID int) error
 	UpdateRunner(runner Runner) error
 	CreateRunner(runner Runner) (Runner, error)