poseidon/api/runners.go

package api

import (
	"fmt"
	"github.com/gorilla/mux"
	"gitlab.hpi.de/codeocean/codemoon/poseidon/api/dto"
	"gitlab.hpi.de/codeocean/codemoon/poseidon/config"
	"gitlab.hpi.de/codeocean/codemoon/poseidon/runner"
	"net/http"
	"net/url"
)

const (
	ExecutePath    = "/execute"
	WebsocketPath  = "/websocket"
	DeleteRoute    = "deleteRunner"
	RunnerIdKey    = "runnerId"
	ExecutionIdKey = "executionId"
)

type RunnerController struct {
	manager      runner.Manager
	runnerRouter *mux.Router
}

// ConfigureRoutes configures a given router with the runner routes of our API.
func (r *RunnerController) ConfigureRoutes(router *mux.Router) {
	runnersRouter := router.PathPrefix(RouteRunners).Subrouter()
	runnersRouter.HandleFunc("", r.provide).Methods(http.MethodPost)
	r.runnerRouter = runnersRouter.PathPrefix(fmt.Sprintf("/{%s}", RunnerIdKey)).Subrouter()
	r.runnerRouter.Use(r.findRunnerMiddleware)
	r.runnerRouter.HandleFunc(ExecutePath, r.execute).Methods(http.MethodPost).Name(ExecutePath)
	r.runnerRouter.HandleFunc(WebsocketPath, connectToRunner).Methods(http.MethodGet).Name(WebsocketPath)
	r.runnerRouter.HandleFunc("", r.delete).Methods(http.MethodDelete).Name(DeleteRoute)
}

// provide handles the provide runners API route.
// It tries to respond with the id of a unused runner.
// This runner is then reserved for future use
func (r *RunnerController) provide(writer http.ResponseWriter, request *http.Request) {
	runnerRequest := new(dto.RunnerRequest)
	if err := parseJSONRequestBody(writer, request, runnerRequest); err != nil {
		return
	}
	environmentId := runner.EnvironmentId(runnerRequest.ExecutionEnvironmentId)
	nextRunner, err := r.manager.Use(environmentId)
	if err != nil {
		if err == runner.ErrUnknownExecutionEnvironment {
			writeNotFound(writer, err)
		} else if err == runner.ErrNoRunnersAvailable {
			writeInternalServerError(writer, err, dto.ErrorNomadOverload)
		} else {
			writeInternalServerError(writer, err, dto.ErrorUnknown)
		}
		return
	}

	sendJson(writer, &dto.RunnerResponse{Id: nextRunner.Id()}, http.StatusOK)
}

// execute handles the execute API route.
// It takes an ExecutionRequest and stores it for a runner.
// It returns a url to connect to for a websocket connection to this execution in the corresponding runner.
func (r *RunnerController) execute(writer http.ResponseWriter, request *http.Request) {
	executionRequest := new(dto.ExecutionRequest)
	if err := parseJSONRequestBody(writer, request, executionRequest); err != nil {
		return
	}

	var scheme string
	if config.Config.Server.TLS {
		scheme = "wss"
	} else {
		scheme = "ws"
	}
	targetRunner, _ := runner.FromContext(request.Context())

	path, err := r.runnerRouter.Get(WebsocketPath).URL(RunnerIdKey, targetRunner.Id())
	if err != nil {
		log.WithError(err).Error("Could not create runner websocket URL.")
		writeInternalServerError(writer, err, dto.ErrorUnknown)
		return
	}
	id, err := targetRunner.AddExecution(*executionRequest)
	if err != nil {
		log.WithError(err).Error("Could not store execution.")
		writeInternalServerError(writer, err, dto.ErrorUnknown)
		return
	}
	websocketUrl := url.URL{
		Scheme:   scheme,
		Host:     request.Host,
		Path:     path.String(),
		RawQuery: fmt.Sprintf("%s=%s", ExecutionIdKey, id),
	}

	sendJson(writer, &dto.WebsocketResponse{WebsocketUrl: websocketUrl.String()}, http.StatusOK)
}

// The findRunnerMiddleware looks up the runnerId for routes containing it
// and adds the runner to the context of the request.
func (r *RunnerController) findRunnerMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
		// Find runner
		runnerId := mux.Vars(request)[RunnerIdKey]
		r, err := r.manager.Get(runnerId)
		if err != nil {
			writeNotFound(writer, err)
			return
		}
		ctx := runner.NewContext(request.Context(), r.(runner.Runner))
		requestWithRunner := request.WithContext(ctx)
		next.ServeHTTP(writer, requestWithRunner)
	})
}

// delete handles the delete runner API route.
// It destroys the given runner on the executor and removes it from the used runners list.
func (r *RunnerController) delete(writer http.ResponseWriter, request *http.Request) {
	targetRunner, _ := runner.FromContext(request.Context())

	err := r.manager.Return(targetRunner)
	if err != nil {
		if err == runner.ErrUnknownExecutionEnvironment {
			writeNotFound(writer, err)
		}

		writeInternalServerError(writer, err, dto.ErrorNomadInternalServerError)
		return
	}

	writer.WriteHeader(http.StatusNoContent)
}