Completes renaming by removing Composition occurrences

Author: grussorusso

internal/api/api.go

@@ -30,9 +30,9 @@ var requestsPool = sync.Pool{
 	},
 }
 
-var compositionRequestsPool = sync.Pool{
+var workflowInvocationRequestPool = sync.Pool{
 	New: func() any {
-		return new(workflow.CompositionRequest)
+		return new(workflow.Request)
 	},
 }
 
@@ -74,7 +74,6 @@ func InvokeFunction(c echo.Context) error {
 	// init fields if possibly not overwritten later
 	r.ExecReport.SchedAction = ""
 	r.ExecReport.OffloadLatency = 0.0
-	r.IsInComposition = false
 
 	if r.Async {
 		go scheduling.SubmitAsyncRequest(r)

internal/api/server.go

@@ -29,12 +29,12 @@ func StartAPIServer(e *echo.Echo) {
 	e.GET("/function", GetFunctions)
 	e.GET("/poll/:reqId", PollAsyncResult)
 	e.GET("/status", GetServerStatus)
-	// Function composition routes
-	e.POST("/play/:workflow", InvokeFunctionComposition)
-	e.POST("/compose", CreateFunctionComposition)
-	e.POST("/composeASL", CreateFunctionCompositionFromASL)
-	e.POST("/uncompose", DeleteFunctionComposition)
-	e.GET("/workflow", GetFunctionCompositions)
+	// Workflow routes
+	e.POST("/workflow/invoke/:workflow", InvokeWorkflow)
+	e.POST("/workflow/create", CreateWorkflowFromASL)
+	e.POST("/workflow/import", CreateWorkflow)
+	e.POST("/workflow/delete", DeleteWorkflow)
+	e.GET("/workflow/list", GetWorkflows)
 
 	// Start server
 	portNumber := config.GetInt(config.API_PORT, 1323)

internal/api/composition.go internal/api/workflow.gointernal/api/composition.go renamed to internal/api/workflow.go

@@ -18,10 +18,8 @@ import (
 	"github.com/labstack/gommon/log"
 )
 
-// ===== Function Composition =====
-
-func CreateFunctionCompositionFromASL(e echo.Context) error {
-	var creationRequest client.CompositionCreationFromASLRequest
+func CreateWorkflowFromASL(e echo.Context) error {
+	var creationRequest client.WorkflowCreationRequest
 	var body []byte
 	body, errReadBody := io.ReadAll(e.Request().Body)
 	if errReadBody != nil {
@@ -37,22 +35,22 @@ func CreateFunctionCompositionFromASL(e echo.Context) error {
 	// checking if the function already exists. If exists we return an error
 	_, found := workflow.GetFC(creationRequest.Name)
 	if found {
-		log.Printf("Dropping request for already existing composition '%s'", creationRequest.Name)
-		return e.JSON(http.StatusConflict, "composition already exists")
+		log.Printf("Dropping request for already existing workflow '%s'", creationRequest.Name)
+		return e.JSON(http.StatusConflict, "workflow already exists")
 	}
 
-	log.Printf("New request: creation of composition %s", creationRequest.Name)
+	log.Printf("New request: creation of workflow %s", creationRequest.Name)
 
 	decodedSrc, err := base64.StdEncoding.DecodeString(creationRequest.ASLSrc)
 	if err != nil {
-		log.Printf("Could not decode composition source ASL: %v", err)
-		return e.JSON(http.StatusBadRequest, "composition already exists")
+		log.Printf("Could not decode workflow source ASL: %v", err)
+		return e.JSON(http.StatusBadRequest, "workflow already exists")
 	}
 
 	comp, err := workflow.FromASL(creationRequest.Name, decodedSrc[:])
 	if err != nil {
-		log.Printf("Could not parse composition from ASL: %v", err)
-		return e.JSON(http.StatusBadRequest, "composition already exists")
+		log.Printf("Could not parse workflow from ASL: %v", err)
+		return e.JSON(http.StatusBadRequest, "workflow already exists")
 	}
 
 	err = comp.SaveToEtcd()
@@ -65,9 +63,9 @@ func CreateFunctionCompositionFromASL(e echo.Context) error {
 	return e.JSON(http.StatusOK, response)
 }
 
-func CreateFunctionComposition(e echo.Context) error {
+func CreateWorkflow(e echo.Context) error {
 	var comp workflow.Workflow
-	// here we expect to receive the function composition struct already parsed from JSON/YAML
+	// here we expect to receive the function workflow struct already parsed from JSON/YAML
 	var body []byte
 	body, errReadBody := io.ReadAll(e.Request().Body)
 	if errReadBody != nil {
@@ -76,24 +74,24 @@ func CreateFunctionComposition(e echo.Context) error {
 
 	err := json.Unmarshal(body, &comp)
 	if err != nil && err != io.EOF {
-		log.Printf("Could not parse composition request - error during unmarshal: %v", err)
+		log.Printf("Could not parse workflow request - error during unmarshal: %v", err)
 		return err
 	}
 	// checking if the function already exists. If exists we return an error
 	alreadyPresent := comp.Exists() // TODO: we would need a system-wide lock here...
 	if alreadyPresent {
-		log.Printf("Dropping request for already existing composition '%s'", comp.Name)
-		return e.JSON(http.StatusConflict, "composition already exists")
+		log.Printf("Dropping request for already existing workflow '%s'", comp.Name)
+		return e.JSON(http.StatusConflict, "workflow already exists")
 	}
 
-	log.Printf("New request: creation of composition %s", comp.Name)
+	log.Printf("New request: creation of workflow %s", comp.Name)
 
 	// Check that functions exist
 	for _, fName := range comp.GetUniqueFunctions() {
 		f, exists := function.GetFunction(fName)
 		if !exists {
-			log.Printf("Dropping request for composition with non-existing function '%s'", fName)
-			return e.JSON(http.StatusBadRequest, "composition with non-existing function")
+			log.Printf("Dropping request for workflow with non-existing function '%s'", fName)
+			return e.JSON(http.StatusBadRequest, "workflow with non-existing function")
 		}
 		if f.Signature == nil {
 			return e.JSON(http.StatusBadRequest, "function "+fName+"has nil signature")
@@ -109,67 +107,67 @@ func CreateFunctionComposition(e echo.Context) error {
 	return e.JSON(http.StatusOK, response)
 }
 
-// GetFunctionCompositions handles a request to list the function compositions available in the system.
-func GetFunctionCompositions(c echo.Context) error {
+// GetWorkflows handles a request to list the function workflows available in the system.
+func GetWorkflows(c echo.Context) error {
 	list, err := workflow.GetAllFC()
 	if err != nil {
 		return c.String(http.StatusServiceUnavailable, "")
 	}
 	return c.JSON(http.StatusOK, list)
 }
 
-// DeleteFunctionComposition handles a function deletion request.
-func DeleteFunctionComposition(c echo.Context) error {
+// DeleteWorkflow handles a function deletion request.
+func DeleteWorkflow(c echo.Context) error {
 	var comp workflow.Workflow
-	// here we only need the name of the function composition (and if all function should be deleted with it)
+	// here we only need the name of the function workflow (and if all function should be deleted with it)
 	err := json.NewDecoder(c.Request().Body).Decode(&comp)
 	if err != nil && err != io.EOF {
 		log.Printf("Could not parse delete request - error during decoding: %v", err)
 		return err
 	}
 
-	composition, ok := workflow.GetFC(comp.Name) // TODO: we would need a system-wide lock here...
+	workflow, ok := workflow.GetFC(comp.Name) // TODO: we would need a system-wide lock here...
 	if !ok {
 		log.Printf("Dropping request for non existing function '%s'", comp.Name)
-		return c.JSON(http.StatusNotFound, "the request function composition to delete does not exist")
+		return c.JSON(http.StatusNotFound, "the request function workflow to delete does not exist")
 	}
 
-	log.Printf("New request: deleting %s", composition.Name)
-	err = composition.Delete()
+	log.Printf("New request: deleting %s", workflow.Name)
+	err = workflow.Delete()
 	if err != nil {
 		log.Printf("Failed deletion: %v", err)
 		return c.JSON(http.StatusServiceUnavailable, "")
 	}
 
-	response := struct{ Deleted string }{composition.Name}
+	response := struct{ Deleted string }{workflow.Name}
 	return c.JSON(http.StatusOK, response)
 }
 
-// InvokeFunctionComposition handles a function composition invocation request.
-func InvokeFunctionComposition(e echo.Context) error {
-	// gets the command line param value for -workflow (the composition name)
+// InvokeWorkflow handles a function workflow invocation request.
+func InvokeWorkflow(e echo.Context) error {
+	// gets the command line param value for -workflow (the workflow name)
 	fcName := e.Param("workflow")
 	funComp, ok := workflow.GetFC(fcName)
 	if !ok {
 		log.Printf("Dropping request for unknown FC '%s'", fcName)
-		return e.JSON(http.StatusNotFound, "function composition '"+fcName+"' does not exist")
+		return e.JSON(http.StatusNotFound, "function workflow '"+fcName+"' does not exist")
 	}
 
-	// we use invocation request that is specific to function compositions
-	var fcInvocationRequest client.CompositionInvocationRequest
+	// we use invocation request that is specific to function workflows
+	var fcInvocationRequest client.WorkflowInvocationRequest
 	err := json.NewDecoder(e.Request().Body).Decode(&fcInvocationRequest)
 	if err != nil && err != io.EOF {
 		log.Printf("Could not parse invoke request - error during decoding: %v", err)
-		return e.JSON(http.StatusInternalServerError, "failed to parse composition invocation request. Check parameters and composition definition")
+		return e.JSON(http.StatusInternalServerError, "failed to parse workflow invocation request. Check parameters and workflow definition")
 	}
-	// gets a workflow.CompositionRequest from the pool goroutine-safe cache.
-	fcReq := compositionRequestsPool.Get().(*workflow.CompositionRequest) // A pointer *function.CompositionRequest will be created if does not exists, otherwise removed from the pool
-	defer compositionRequestsPool.Put(fcReq)                              // at the end of the function, the function.CompositionRequest is added to the pool.
-	fcReq.Fc = funComp
+	// gets a workflow.NewRequest from the pool goroutine-safe cache.
+	fcReq := workflowInvocationRequestPool.Get().(*workflow.Request) // A pointer *function.NewRequest will be created if does not exists, otherwise removed from the pool
+	defer workflowInvocationRequestPool.Put(fcReq)                   // at the end of the function, the function.NewRequest is added to the pool.
+	fcReq.W = funComp
 	fcReq.Params = fcInvocationRequest.Params
 	fcReq.Arrival = time.Now()
 
-	// instead of saving only one RequestQoS, we save a map with an entry for each function in the composition
+	// instead of saving only one RequestQoS, we save a map with an entry for each function in the workflow
 	fcReq.RequestQoSMap = fcInvocationRequest.RequestQoSMap
 
 	fcReq.CanDoOffloading = fcInvocationRequest.CanDoOffloading
@@ -187,12 +185,12 @@ func InvokeFunctionComposition(e echo.Context) error {
 	}
 
 	if fcReq.Async {
-		go workflow.SubmitAsyncCompositionRequest(fcReq)
+		go workflow.SubmitAsyncWorkflowInvocationRequest(fcReq)
 		return e.JSON(http.StatusOK, function.AsyncResponse{ReqId: fcReq.ReqId})
 	}
 
 	// sync execution
-	err = workflow.SubmitCompositionRequest(fcReq)
+	err = workflow.SubmitWorkflowInvocationRequest(fcReq)
 
 	if errors.Is(err, node.OutOfResourcesErr) {
 		return e.String(http.StatusTooManyRequests, "")
@@ -213,7 +211,7 @@ func InvokeFunctionComposition(e echo.Context) error {
 			return true
 		})
 
-		return e.JSON(http.StatusOK, workflow.CompositionResponse{
+		return e.JSON(http.StatusOK, workflow.InvocationResponse{
 			Success:      true,
 			Result:       fcReq.ExecReport.Result,
 			Reports:      reports,