added poseidon with aws to k8s changes

2024-08-12 10:02:36 +02:00
parent 5376f7a027
commit 254460d64c
60 changed files with 6912 additions and 0 deletions
--- a/internal/api/runners.go
+++ b/internal/api/runners.go
@ -0,0 +1,259 @@
+package api
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/google/uuid"
+	"github.com/gorilla/mux"
+	"github.com/openHPI/poseidon/internal/config"
+	"github.com/openHPI/poseidon/internal/runner"
+	"github.com/openHPI/poseidon/pkg/dto"
+	"github.com/openHPI/poseidon/pkg/logging"
+	"github.com/openHPI/poseidon/pkg/monitoring"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+)
+
+const (
+	ExecutePath             = "/execute"
+	WebsocketPath           = "/websocket"
+	UpdateFileSystemPath    = "/files"
+	ListFileSystemRouteName = UpdateFileSystemPath + "_list"
+	FileContentRawPath      = UpdateFileSystemPath + "/raw"
+	ProvideRoute            = "provideRunner"
+	DeleteRoute             = "deleteRunner"
+	RunnerIDKey             = "runnerId"
+	ExecutionIDKey          = "executionID"
+	PathKey                 = "path"
+	RecursiveKey            = "recursive"
+	PrivilegedExecutionKey  = "privilegedExecution"
+)
+
+var ErrForbiddenCharacter = errors.New("use of forbidden character")
+
+type RunnerController struct {
+	manager      runner.Accessor
+	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.listFileSystem).Methods(http.MethodGet).
+		Name(ListFileSystemRouteName)
+	r.runnerRouter.HandleFunc(UpdateFileSystemPath, r.updateFileSystem).Methods(http.MethodPatch).
+		Name(UpdateFileSystemPath)
+	r.runnerRouter.HandleFunc(FileContentRawPath, r.fileContent).Methods(http.MethodGet).Name(FileContentRawPath)
+	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 := dto.EnvironmentID(runnerRequest.ExecutionEnvironmentID)
+
+	var nextRunner runner.Runner
+	var err error
+	logging.StartSpan("api.runner.claim", "Claim Runner", request.Context(), func(_ context.Context) {
+		nextRunner, err = r.manager.Claim(environmentID, runnerRequest.InactivityTimeout)
+	})
+	if err != nil {
+		switch {
+		case errors.Is(err, runner.ErrUnknownExecutionEnvironment):
+			writeClientError(writer, err, http.StatusNotFound, request.Context())
+		case errors.Is(err, runner.ErrNoRunnersAvailable):
+			log.WithContext(request.Context()).Warn("No runners available")
+			writeInternalServerError(writer, err, dto.Errork8sOverload, request.Context())
+		default:
+			writeInternalServerError(writer, err, dto.ErrorUnknown, request.Context())
+		}
+		return
+	}
+	monitoring.AddRunnerMonitoringData(request, nextRunner.ID(), nextRunner.Environment())
+	sendJSON(writer, &dto.RunnerResponse{ID: nextRunner.ID(), MappedPorts: nextRunner.MappedPorts()},
+		http.StatusOK, request.Context())
+}
+
+// listFileSystem handles the files API route with the method GET.
+// It returns a listing of the file system of the provided runner.
+func (r *RunnerController) listFileSystem(writer http.ResponseWriter, request *http.Request) {
+	targetRunner, _ := runner.FromContext(request.Context())
+
+	recursiveRaw := request.URL.Query().Get(RecursiveKey)
+	recursive, err := strconv.ParseBool(recursiveRaw)
+	recursive = err != nil || recursive
+
+	path := request.URL.Query().Get(PathKey)
+	if path == "" {
+		path = "./"
+	}
+	privilegedExecution, err := strconv.ParseBool(request.URL.Query().Get(PrivilegedExecutionKey))
+	if err != nil {
+		privilegedExecution = false
+	}
+
+	writer.Header().Set("Content-Type", "application/json")
+	logging.StartSpan("api.fs.list", "List File System", request.Context(), func(ctx context.Context) {
+		err = targetRunner.ListFileSystem(path, recursive, writer, privilegedExecution, ctx)
+	})
+	if errors.Is(err, runner.ErrFileNotFound) {
+		writeClientError(writer, err, http.StatusFailedDependency, request.Context())
+		return
+	} else if err != nil {
+		log.WithContext(request.Context()).WithError(err).Error("Could not perform the requested listFileSystem.")
+		writeInternalServerError(writer, err, dto.ErrorUnknown, request.Context())
+		return
+	}
+}
+
+// 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) {
+	monitoring.AddRequestSize(request)
+	fileCopyRequest := new(dto.UpdateFileSystemRequest)
+	if err := parseJSONRequestBody(writer, request, fileCopyRequest); err != nil {
+		return
+	}
+
+	targetRunner, _ := runner.FromContext(request.Context())
+
+	var err error
+	logging.StartSpan("api.fs.update", "Update File System", request.Context(), func(ctx context.Context) {
+		err = targetRunner.UpdateFileSystem(fileCopyRequest, ctx)
+	})
+	if err != nil {
+		log.WithContext(request.Context()).WithError(err).Error("Could not perform the requested updateFileSystem.")
+		writeInternalServerError(writer, err, dto.ErrorUnknown, request.Context())
+		return
+	}
+
+	writer.WriteHeader(http.StatusNoContent)
+}
+
+func (r *RunnerController) fileContent(writer http.ResponseWriter, request *http.Request) {
+	targetRunner, _ := runner.FromContext(request.Context())
+	path := request.URL.Query().Get(PathKey)
+	privilegedExecution, err := strconv.ParseBool(request.URL.Query().Get(PrivilegedExecutionKey))
+	if err != nil {
+		privilegedExecution = false
+	}
+
+	writer.Header().Set("Content-Disposition", "attachment; filename=\""+path+"\"")
+	logging.StartSpan("api.fs.read", "File Content", request.Context(), func(ctx context.Context) {
+		err = targetRunner.GetFileContent(path, writer, privilegedExecution, ctx)
+	})
+	if errors.Is(err, runner.ErrFileNotFound) {
+		writeClientError(writer, err, http.StatusFailedDependency, request.Context())
+		return
+	} else if err != nil {
+		log.WithContext(request.Context()).WithError(err).Error("Could not retrieve the requested file.")
+		writeInternalServerError(writer, err, dto.ErrorUnknown, request.Context())
+		return
+	}
+}
+
+// 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
+	}
+	forbiddenCharacters := "'"
+	if strings.ContainsAny(executionRequest.Command, forbiddenCharacters) {
+		writeClientError(writer, ErrForbiddenCharacter, http.StatusBadRequest, request.Context())
+		return
+	}
+
+	var scheme string
+	if config.Config.Server.TLS.Active {
+		scheme = "wss"
+	} else {
+		scheme = "ws"
+	}
+	targetRunner, _ := runner.FromContext(request.Context())
+
+	path, err := r.runnerRouter.Get(WebsocketPath).URL(RunnerIDKey, targetRunner.ID())
+	if err != nil {
+		log.WithContext(request.Context()).WithError(err).Error("Could not create runner websocket URL.")
+		writeInternalServerError(writer, err, dto.ErrorUnknown, request.Context())
+		return
+	}
+	newUUID, err := uuid.NewRandom()
+	if err != nil {
+		log.WithContext(request.Context()).WithError(err).Error("Could not create execution id")
+		writeInternalServerError(writer, err, dto.ErrorUnknown, request.Context())
+		return
+	}
+	id := newUUID.String()
+
+	logging.StartSpan("api.runner.exec", "Store Execution", request.Context(), func(ctx context.Context) {
+		targetRunner.StoreExecution(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, request.Context())
+}
+
+// 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 {
+			// We discard the request body because an early write causes errors for some clients.
+			// See https://github.com/openHPI/poseidon/issues/54
+			_, readErr := io.ReadAll(request.Body)
+			if readErr != nil {
+				log.WithContext(request.Context()).WithError(readErr).Debug("Failed to discard the request body")
+			}
+			writeClientError(writer, err, http.StatusGone, request.Context())
+			return
+		}
+		ctx := runner.NewContext(request.Context(), targetRunner)
+		ctx = context.WithValue(ctx, dto.ContextKey(dto.KeyRunnerID), targetRunner.ID())
+		ctx = context.WithValue(ctx, dto.ContextKey(dto.KeyEnvironmentID), targetRunner.Environment().ToString())
+		requestWithRunner := request.WithContext(ctx)
+		monitoring.AddRunnerMonitoringData(requestWithRunner, targetRunner.ID(), targetRunner.Environment())
+
+		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())
+
+	var err error
+	logging.StartSpan("api.runner.delete", "Return Runner", request.Context(), func(ctx context.Context) {
+		err = r.manager.Return(targetRunner)
+	})
+	if err != nil {
+		writeInternalServerError(writer, err, dto.Errork8sInternalServerError, request.Context())
+		return
+	}
+
+	writer.WriteHeader(http.StatusNoContent)
+}