Restructure project

We previously didn't really had any structure in our project apart
from creating a new folder for each package in our project root.
Now that we have accumulated some packages, we use the well-known
Golang project layout in order to clearly communicate our intent
with packages. See https://github.com/golang-standards/project-layout

internal/api/runners.go

@@ -0,0 +1,159 @@
+package api
+
+import (
+	"errors"
+	"fmt"
+	"github.com/google/uuid"
+	"github.com/gorilla/mux"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/internal/config"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/internal/runner"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/pkg/dto"
+	"net/http"
+	"net/url"
+)
+
+const (
+	ExecutePath          = "/execute"
+	WebsocketPath        = "/websocket"
+	UpdateFileSystemPath = "/files"
+	DeleteRoute          = "deleteRunner"
+	RunnerIDKey          = "runnerId"
+	ExecutionIDKey       = "executionID"
+	ProvideRoute         = "provideRunner"
+)
+
+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(RunnersPath).Subrouter()
+	runnersRouter.HandleFunc("", r.provide).Methods(http.MethodPost).Name(ProvideRoute)
+	r.runnerRouter = runnersRouter.PathPrefix(fmt.Sprintf("/{%s}", RunnerIDKey)).Subrouter()
+	r.runnerRouter.Use(r.findRunnerMiddleware)
+	r.runnerRouter.HandleFunc(UpdateFileSystemPath, r.updateFileSystem).Methods(http.MethodPatch).
+		Name(UpdateFileSystemPath)
+	r.runnerRouter.HandleFunc(ExecutePath, r.execute).Methods(http.MethodPost).Name(ExecutePath)
+	r.runnerRouter.HandleFunc(WebsocketPath, r.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.Claim(environmentID, runnerRequest.InactivityTimeout)
+	if err != nil {
+		switch err {
+		case runner.ErrUnknownExecutionEnvironment:
+			writeNotFound(writer, err)
+		case runner.ErrNoRunnersAvailable:
+			log.WithField("environment", environmentID).Warn("No runners available")
+			writeInternalServerError(writer, err, dto.ErrorNomadOverload)
+		default:
+			writeInternalServerError(writer, err, dto.ErrorUnknown)
+		}
+		return
+	}
+	sendJSON(writer, &dto.RunnerResponse{ID: nextRunner.ID(), MappedPorts: nextRunner.MappedPorts()}, http.StatusOK)
+}
+
+// updateFileSystem handles the files API route.
+// It takes an dto.UpdateFileSystemRequest and sends it to the runner for processing.
+func (r *RunnerController) updateFileSystem(writer http.ResponseWriter, request *http.Request) {
+	fileCopyRequest := new(dto.UpdateFileSystemRequest)
+	if err := parseJSONRequestBody(writer, request, fileCopyRequest); err != nil {
+		return
+	}
+
+	targetRunner, _ := runner.FromContext(request.Context())
+	if err := targetRunner.UpdateFileSystem(fileCopyRequest); err != nil {
+		log.WithError(err).Error("Could not perform the requested updateFileSystem.")
+		writeInternalServerError(writer, err, dto.ErrorUnknown)
+		return
+	}
+
+	writer.WriteHeader(http.StatusNoContent)
+}
+
+// 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
+	}
+	newUUID, err := uuid.NewRandom()
+	if err != nil {
+		log.WithError(err).Error("Could not create execution id")
+		writeInternalServerError(writer, err, dto.ErrorUnknown)
+		return
+	}
+	id := runner.ExecutionID(newUUID.String())
+	targetRunner.Add(id, executionRequest)
+	webSocketURL := url.URL{
+		Scheme:   scheme,
+		Host:     request.Host,
+		Path:     path.String(),
+		RawQuery: fmt.Sprintf("%s=%s", ExecutionIDKey, id),
+	}
+
+	sendJSON(writer, &dto.ExecutionResponse{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) {
+		runnerID := mux.Vars(request)[RunnerIDKey]
+		targetRunner, err := r.manager.Get(runnerID)
+		if err != nil {
+			writeNotFound(writer, err)
+			return
+		}
+		ctx := runner.NewContext(request.Context(), targetRunner)
+		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 errors.Is(err, runner.ErrUnknownExecutionEnvironment) {
+			writeNotFound(writer, err)
+		} else {
+			writeInternalServerError(writer, err, dto.ErrorNomadInternalServerError)
+		}
+		return
+	}
+
+	writer.WriteHeader(http.StatusNoContent)
+}