122 lines
4.2 KiB
Go
122 lines
4.2 KiB
Go
package api
|
|
|
|
import (
|
|
"errors"
|
|
"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/environment"
|
|
"gitlab.hpi.de/codeocean/codemoon/poseidon/environment/pool"
|
|
"gitlab.hpi.de/codeocean/codemoon/poseidon/runner"
|
|
"net/http"
|
|
"net/url"
|
|
)
|
|
|
|
const (
|
|
ExecutePath = "/execute"
|
|
WebsocketPath = "/websocket"
|
|
RunnerIdKey = "runnerId"
|
|
ExecutionIdKey = "executionId"
|
|
)
|
|
|
|
// provideRunner tries to respond with the id of a runner
|
|
// This runner is then reserved for future use
|
|
func provideRunner(writer http.ResponseWriter, request *http.Request) {
|
|
runnerRequest := new(dto.RunnerRequest)
|
|
if err := parseJSONRequestBody(writer, request, runnerRequest); err != nil {
|
|
return
|
|
}
|
|
env, err := environment.GetExecutionEnvironment(runnerRequest.ExecutionEnvironmentId)
|
|
if err != nil {
|
|
writeNotFound(writer, err)
|
|
return
|
|
}
|
|
runner, err := env.NextRunner()
|
|
if err != nil {
|
|
writeInternalServerError(writer, err, dto.ErrorNomadOverload)
|
|
return
|
|
}
|
|
sendJson(writer, &dto.RunnerResponse{Id: runner.Id()}, http.StatusOK)
|
|
}
|
|
|
|
// executeCommand 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 executeCommand(router *mux.Router) func(w http.ResponseWriter, r *http.Request) {
|
|
return func(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"
|
|
}
|
|
r, ok := runner.FromContext(request.Context())
|
|
if !ok {
|
|
log.Error("Runner not set in request context.")
|
|
writeInternalServerError(writer, errors.New("findRunnerMiddleware failure"), dto.ErrorUnknown)
|
|
return
|
|
}
|
|
|
|
path, err := router.Get(WebsocketPath).URL(RunnerIdKey, r.Id())
|
|
if err != nil {
|
|
log.WithError(err).Error("Could not create runner websocket URL.")
|
|
writeInternalServerError(writer, err, dto.ErrorUnknown)
|
|
return
|
|
}
|
|
id, err := r.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)
|
|
}
|
|
}
|
|
|
|
// connectToRunner is a placeholder for now and will become the endpoint for websocket connections.
|
|
func connectToRunner(writer http.ResponseWriter, request *http.Request) {
|
|
// Todo: Execute the command, upgrade the connection to websocket and handle forwarding
|
|
executionId := request.URL.Query()[ExecutionIdKey]
|
|
log.WithField("executionId", executionId).Info("Websocket for execution requested.")
|
|
writer.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// The findRunnerMiddleware looks up the runnerId for routes containing it
|
|
// and adds the runner to the context of the request.
|
|
func findRunnerMiddleware(runnerPool pool.RunnerPool) func(handler http.Handler) http.Handler {
|
|
return func(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
|
|
// Find runner
|
|
runnerId := mux.Vars(request)[RunnerIdKey]
|
|
r, ok := runnerPool.GetRunner(runnerId)
|
|
if !ok {
|
|
writer.WriteHeader(http.StatusNotFound)
|
|
return
|
|
}
|
|
ctx := runner.NewContext(request.Context(), r)
|
|
requestWithRunner := request.WithContext(ctx)
|
|
next.ServeHTTP(writer, requestWithRunner)
|
|
})
|
|
}
|
|
}
|
|
|
|
func registerRunnerRoutes(router *mux.Router, runnerPool pool.RunnerPool) {
|
|
router.HandleFunc("", provideRunner).Methods(http.MethodPost)
|
|
runnerRouter := router.PathPrefix(fmt.Sprintf("/{%s}", RunnerIdKey)).Subrouter()
|
|
runnerRouter.Use(findRunnerMiddleware(runnerPool))
|
|
runnerRouter.HandleFunc(ExecutePath, executeCommand(runnerRouter)).Methods(http.MethodPost).Name(ExecutePath)
|
|
runnerRouter.HandleFunc(WebsocketPath, connectToRunner).Methods(http.MethodGet).Name(WebsocketPath)
|
|
}
|