[YUNIKORN-3121] Add REST Endpoint for Scheduling Order Visibility

Author: mitdesai

pkg/scheduler/objects/queue.go

@@ -1233,6 +1233,49 @@ func (sq *Queue) sortQueues() []*Queue {
 	return sortedQueues
 }
 
+// GetSchedulingOrder returns a sorted shallow copy of the queues for this parent queue along with
+// their eligible applications that would be tried in the current scheduling cycle.
+// This follows the same logic as TryAllocate method.
+// Only queues with a pending resource request are considered. The queues are sorted using the
+// sorting type for the parent queue.
+// Lock free call all locks are taken when needed in called functions
+func (sq *Queue) GetSchedulingOrder() []*dao.SchedulingOrderDAO {
+	if sq.IsLeafQueue() {
+		// For leaf queues, return the queue with its eligible applications
+		appIDs := make([]string, 0)
+
+		// Process the apps (filters out app without pending requests) - same logic as TryAllocate
+		for _, app := range sq.sortApplications(false) {
+			runnableInQueue := sq.canRunApp(app.ApplicationID)
+			runnableByUserLimit := ugm.GetUserManager().CanRunApp(sq.QueuePath, app.ApplicationID, app.user)
+			app.updateRunnableStatus(runnableInQueue, runnableByUserLimit)
+			if app.IsAccepted() && (!runnableInQueue || !runnableByUserLimit) {
+				continue
+			}
+			appIDs = append(appIDs, app.ApplicationID)
+		}
+
+		// Only return this queue if it has eligible applications or pending resources
+		if len(appIDs) > 0 || resources.StrictlyGreaterThanZero(sq.GetPendingResource()) {
+			return []*dao.SchedulingOrderDAO{{
+				QueueName:      sq.QueuePath,
+				ApplicationIDs: appIDs,
+			}}
+		}
+		return nil
+	} else {
+		// For parent queues, process child queues - same logic as TryAllocate
+		result := make([]*dao.SchedulingOrderDAO, 0)
+
+		// Process each sorted child queue using the original sortQueues method
+		for _, child := range sq.sortQueues() {
+			childInfo := child.GetSchedulingOrder()
+			result = append(result, childInfo...)
+		}
+		return result
+	}
+}
+
 // getHeadRoom returns the headroom for the queue. This can never be more than the headroom for the parent.
 // In case there are no nodes in a newly started cluster and no queues have a limit configured this call
 // will return nil.

pkg/scheduler/partition.go

@@ -507,6 +507,11 @@ func (pc *PartitionContext) GetPartitionQueues() dao.PartitionQueueDAOInfo {
 	return partitionQueueDAOInfo
 }
 
+// GetPartitionSchedulingOrder builds the sorted queue info for the whole queue structure to pass to the webservice
+func (pc *PartitionContext) GetPartitionSchedulingOrder() []*dao.SchedulingOrderDAO {
+	return pc.root.GetSchedulingOrder()
+}
+
 // GetPlacementRules returns the current active rule set as dao to expose to the webservice
 func (pc *PartitionContext) GetPlacementRules() []*dao.RuleDAO {
 	return pc.getPlacementManager().GetRulesDAO()

pkg/webservice/dao/scheduling_order.go

@@ -0,0 +1,23 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+     http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+package dao
+
+// SchedulingOrderDAO contains queue and application information for scheduling order
+type SchedulingOrderDAO struct {
+	QueueName      string   `json:"queueName"`
+	ApplicationIDs []string `json:"applicationIDs"` // Application IDs that would be tried in current scheduling cycle
+}

pkg/webservice/handlers.go

@@ -714,6 +714,27 @@ func getPartitionQueues(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func getPartitionSchedulingOrder(w http.ResponseWriter, r *http.Request) {
+	writeHeaders(w, r.Method)
+	vars := httprouter.ParamsFromContext(r.Context())
+	if vars == nil {
+		buildJSONErrorResponse(w, MissingParamsName, http.StatusBadRequest)
+		return
+	}
+	partitionName := vars.ByName("partition")
+	var partitionSchedulingOrderDAOInfo []*dao.SchedulingOrderDAO
+	var partition = schedulerContext.Load().GetPartitionWithoutClusterID(partitionName)
+	if partition != nil {
+		partitionSchedulingOrderDAOInfo = partition.GetPartitionSchedulingOrder()
+	} else {
+		buildJSONErrorResponse(w, PartitionDoesNotExists, http.StatusNotFound)
+		return
+	}
+	if err := json.NewEncoder(w).Encode(partitionSchedulingOrderDAOInfo); err != nil {
+		buildJSONErrorResponse(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
 func getPartitionQueue(w http.ResponseWriter, r *http.Request) {
 	writeHeaders(w, r.Method)
 	vars := httprouter.ParamsFromContext(r.Context())

pkg/webservice/handlers_test.go

@@ -3008,6 +3008,119 @@ func TestSetMaxRESTResponseSize(t *testing.T) {
 	assert.Equal(t, uint64(10000), maxRESTResponseSize.Load())
 }
 
+func TestGetPartitionSchedulingOrderHandler(t *testing.T) {
+	// Setup partition with default configuration
+	part := setup(t, configDefault, 1)
+
+	// Create applications with pending requests to trigger scheduling order
+	app1 := addApp(t, "app-1", part, "root.default", false)
+	app2 := addApp(t, "app-2", part, "root.default", false)
+	app3 := addApp(t, "app-3", part, "root.default", false)
+
+	// Add pending allocation requests to applications
+	res1 := &si.Resource{
+		Resources: map[string]*si.Quantity{"memory": {Value: 100}, "vcore": {Value: 1}},
+	}
+	ask1 := objects.NewAllocationFromSI(&si.Allocation{
+		ApplicationID:    "app-1",
+		PartitionName:    part.Name,
+		ResourcePerAlloc: res1})
+	err := app1.AddAllocationAsk(ask1)
+	assert.NilError(t, err, "ask should have been added to app-1")
+
+	res2 := &si.Resource{
+		Resources: map[string]*si.Quantity{"memory": {Value: 200}, "vcore": {Value: 2}},
+	}
+	ask2 := objects.NewAllocationFromSI(&si.Allocation{
+		ApplicationID:    "app-2",
+		PartitionName:    part.Name,
+		ResourcePerAlloc: res2})
+	err = app2.AddAllocationAsk(ask2)
+	assert.NilError(t, err, "ask should have been added to app-2")
+
+	res3 := &si.Resource{
+		Resources: map[string]*si.Quantity{"memory": {Value: 150}, "vcore": {Value: 1}},
+	}
+	ask3 := objects.NewAllocationFromSI(&si.Allocation{
+		ApplicationID:    "app-3",
+		PartitionName:    part.Name,
+		ResourcePerAlloc: res3})
+	err = app3.AddAllocationAsk(ask3)
+	assert.NilError(t, err, "ask should have been added to app-3")
+
+	NewWebApp(schedulerContext.Load(), nil)
+
+	// Test successful scheduling order retrieval
+	var req *http.Request
+	req, err = createRequest(t, "/ws/v1/partition/default/schedulingorder", map[string]string{"partition": partitionNameWithoutClusterID})
+	assert.NilError(t, err, "Get Scheduling Order Handler request failed")
+	resp := &MockResponseWriter{}
+	var schedulingOrderDao []*dao.SchedulingOrderDAO
+	getPartitionSchedulingOrder(resp, req)
+	err = json.Unmarshal(resp.outputBytes, &schedulingOrderDao)
+	assert.NilError(t, err, unmarshalError)
+
+	// Validate response structure and content
+	assert.Assert(t, len(schedulingOrderDao) > 0, "scheduling order should contain at least one queue")
+
+	// Verify that queues with pending resources are included
+	queueFound := false
+	for _, queueOrder := range schedulingOrderDao {
+		if queueOrder.QueueName == "root.default" {
+			queueFound = true
+			// Verify that applications with pending requests are included
+			assert.Assert(t, len(queueOrder.ApplicationIDs) >= 3, "queue root.default should have at least 3 applications")
+			// Check that our test applications are in the list
+			appFound1, appFound2, appFound3 := false, false, false
+			for _, appID := range queueOrder.ApplicationIDs {
+				if appID == "app-1" {
+					appFound1 = true
+				}
+				if appID == "app-2" {
+					appFound2 = true
+				}
+				if appID == "app-3" {
+					appFound3 = true
+				}
+			}
+			assert.Assert(t, appFound1, "app-1 should be in scheduling order")
+			assert.Assert(t, appFound2, "app-2 should be in scheduling order")
+			assert.Assert(t, appFound3, "app-3 should be in scheduling order")
+		}
+	}
+	assert.Assert(t, queueFound, "queue root.default should be found in scheduling order")
+
+	// Test nonexistent partition
+	req, err = createRequest(t, "/ws/v1/partition/default/schedulingorder", map[string]string{"partition": "notexists"})
+	assert.NilError(t, err, "Get Scheduling Order Handler request failed")
+	resp = &MockResponseWriter{}
+	getPartitionSchedulingOrder(resp, req)
+	assertPartitionNotExists(t, resp)
+
+	// Test missing params name
+	req, err = http.NewRequest("GET", "/ws/v1/partition/default/schedulingorder", strings.NewReader(""))
+	assert.NilError(t, err, "Get Scheduling Order Handler request failed")
+	resp = &MockResponseWriter{}
+	getPartitionSchedulingOrder(resp, req)
+	assertParamsMissing(t, resp)
+
+	// Test empty scheduling order (partition with no pending requests)
+	// Create a new partition with no applications
+	emptyPart := setup(t, configDefault, 1)
+	// Add an application but without pending requests
+	addApp(t, "app-empty", emptyPart, "root.default", false)
+
+	req, err = createRequest(t, "/ws/v1/partition/default/schedulingorder", map[string]string{"partition": partitionNameWithoutClusterID})
+	assert.NilError(t, err, "Get Scheduling Order Handler request failed")
+	resp = &MockResponseWriter{}
+	var emptySchedulingOrderDao []*dao.SchedulingOrderDAO
+	getPartitionSchedulingOrder(resp, req)
+	err = json.Unmarshal(resp.outputBytes, &emptySchedulingOrderDao)
+	assert.NilError(t, err, unmarshalError)
+	// Should return empty array when no queues have pending resources
+	assert.Equal(t, len(emptySchedulingOrderDao), 0, "scheduling order should be empty when no pending requests exist")
+}
+
 type ResponseRecorderWithDeadline struct {
 	*httptest.ResponseRecorder
 	setWriteFails   bool

pkg/webservice/routes.go

@@ -90,6 +90,12 @@ var webRoutes = routes{
 		"/ws/v1/partition/:partition/queues",
 		getPartitionQueues,
 	},
+	route{
+		"Scheduler",
+		"GET",
+		"/ws/v1/partition/:partition/schedulingorder",
+		getPartitionSchedulingOrder,
+	},
 	route{
 		"Scheduler",
 		"GET",