This is an automated email from the ASF dual-hosted git repository.
wilfreds pushed a commit to branch branch-1.4
in repository https://gitbox.apache.org/repos/asf/yunikorn-core.git
The following commit(s) were added to refs/heads/branch-1.4 by this push:
new ea623cd5 [YUNIKORN-2139] Pass split queue path in ugm (#709)
ea623cd5 is described below
commit ea623cd5ec24bb5d75b36f263a3c31c5eec44de8
Author: Manikandan R <[email protected]>
AuthorDate: Mon Nov 13 09:57:43 2023 +1100
[YUNIKORN-2139] Pass split queue path in ugm (#709)
Move queuepath split from user and group trackers to manager. Reduce
number of calls to split the queue path string.
Closes: #709
Signed-off-by: Wilfred Spiegelenburg <[email protected]>
---
pkg/scheduler/ugm/group_tracker.go | 38 ++++++++--------
pkg/scheduler/ugm/group_tracker_test.go | 62 +++++++++++++-------------
pkg/scheduler/ugm/manager.go | 79 ++++++++++++++++++---------------
pkg/scheduler/ugm/user_tracker.go | 39 ++++++++--------
pkg/scheduler/ugm/user_tracker_test.go | 72 +++++++++++++++++-------------
5 files changed, 153 insertions(+), 137 deletions(-)
diff --git a/pkg/scheduler/ugm/group_tracker.go
b/pkg/scheduler/ugm/group_tracker.go
index f1b6272a..6987d5cf 100644
--- a/pkg/scheduler/ugm/group_tracker.go
+++ b/pkg/scheduler/ugm/group_tracker.go
@@ -19,11 +19,9 @@
package ugm
import (
- "strings"
"sync"
"github.com/apache/yunikorn-core/pkg/common"
- "github.com/apache/yunikorn-core/pkg/common/configs"
"github.com/apache/yunikorn-core/pkg/common/resources"
"github.com/apache/yunikorn-core/pkg/webservice/dao"
)
@@ -46,17 +44,17 @@ func newGroupTracker(group string) *GroupTracker {
return groupTracker
}
-func (gt *GroupTracker) increaseTrackedResource(queuePath, applicationID
string, usage *resources.Resource, user string) bool {
+func (gt *GroupTracker) increaseTrackedResource(hierarchy []string,
applicationID string, usage *resources.Resource, user string) bool {
if gt == nil {
return true
}
gt.Lock()
defer gt.Unlock()
gt.applications[applicationID] = user
- return gt.queueTracker.increaseTrackedResource(strings.Split(queuePath,
configs.DOT), applicationID, group, usage)
+ return gt.queueTracker.increaseTrackedResource(hierarchy,
applicationID, group, usage)
}
-func (gt *GroupTracker) decreaseTrackedResource(queuePath, applicationID
string, usage *resources.Resource, removeApp bool) (bool, bool) {
+func (gt *GroupTracker) decreaseTrackedResource(hierarchy []string,
applicationID string, usage *resources.Resource, removeApp bool) (bool, bool) {
if gt == nil {
return false, true
}
@@ -65,7 +63,7 @@ func (gt *GroupTracker) decreaseTrackedResource(queuePath,
applicationID string,
if removeApp {
delete(gt.applications, applicationID)
}
- return gt.queueTracker.decreaseTrackedResource(strings.Split(queuePath,
configs.DOT), applicationID, usage, removeApp)
+ return gt.queueTracker.decreaseTrackedResource(hierarchy,
applicationID, usage, removeApp)
}
func (gt *GroupTracker) getTrackedApplications() map[string]string {
@@ -74,16 +72,16 @@ func (gt *GroupTracker) getTrackedApplications()
map[string]string {
return gt.applications
}
-func (gt *GroupTracker) setLimits(queuePath string, resource
*resources.Resource, maxApps uint64) {
+func (gt *GroupTracker) setLimits(hierarchy []string, resource
*resources.Resource, maxApps uint64) {
gt.Lock()
defer gt.Unlock()
- gt.queueTracker.setLimit(strings.Split(queuePath, configs.DOT),
resource, maxApps)
+ gt.queueTracker.setLimit(hierarchy, resource, maxApps)
}
-func (gt *GroupTracker) headroom(queuePath string) *resources.Resource {
+func (gt *GroupTracker) headroom(hierarchy []string) *resources.Resource {
gt.Lock()
defer gt.Unlock()
- return gt.queueTracker.headroom(strings.Split(queuePath, configs.DOT),
group)
+ return gt.queueTracker.headroom(hierarchy, group)
}
func (gt *GroupTracker) GetGroupResourceUsageDAOInfo()
*dao.GroupResourceUsageDAOInfo {
@@ -100,22 +98,22 @@ func (gt *GroupTracker) GetGroupResourceUsageDAOInfo()
*dao.GroupResourceUsageDA
return groupResourceUsage
}
-func (gt *GroupTracker) IsQueuePathTrackedCompletely(queuePath string) bool {
+func (gt *GroupTracker) IsQueuePathTrackedCompletely(hierarchy []string) bool {
gt.RLock()
defer gt.RUnlock()
- return
gt.queueTracker.IsQueuePathTrackedCompletely(strings.Split(queuePath,
configs.DOT))
+ return gt.queueTracker.IsQueuePathTrackedCompletely(hierarchy)
}
-func (gt *GroupTracker) IsUnlinkRequired(queuePath string) bool {
+func (gt *GroupTracker) IsUnlinkRequired(hierarchy []string) bool {
gt.RLock()
defer gt.RUnlock()
- return gt.queueTracker.IsUnlinkRequired(strings.Split(queuePath,
configs.DOT))
+ return gt.queueTracker.IsUnlinkRequired(hierarchy)
}
-func (gt *GroupTracker) UnlinkQT(queuePath string) bool {
+func (gt *GroupTracker) UnlinkQT(hierarchy []string) bool {
gt.RLock()
defer gt.RUnlock()
- return gt.queueTracker.UnlinkQT(strings.Split(queuePath, configs.DOT))
+ return gt.queueTracker.UnlinkQT(hierarchy)
}
func (gt *GroupTracker) canBeRemoved() bool {
@@ -131,13 +129,13 @@ func (gt *GroupTracker) getName() string {
return gt.groupName
}
-func (gt *GroupTracker) decreaseAllTrackedResourceUsage(queuePath string)
map[string]string {
+func (gt *GroupTracker) decreaseAllTrackedResourceUsage(hierarchy []string)
map[string]string {
if gt == nil {
return nil
}
gt.Lock()
defer gt.Unlock()
- applications :=
gt.queueTracker.decreaseTrackedResourceUsageDownwards(strings.Split(queuePath,
configs.DOT))
+ applications :=
gt.queueTracker.decreaseTrackedResourceUsageDownwards(hierarchy)
removedApplications := make(map[string]string)
for app := range applications {
if u, ok := gt.applications[app]; ok {
@@ -147,8 +145,8 @@ func (gt *GroupTracker)
decreaseAllTrackedResourceUsage(queuePath string) map[st
return removedApplications
}
-func (gt *GroupTracker) canRunApp(queuePath, applicationID string) bool {
+func (gt *GroupTracker) canRunApp(hierarchy []string, applicationID string)
bool {
gt.Lock()
defer gt.Unlock()
- return gt.queueTracker.canRunApp(strings.Split(queuePath, configs.DOT),
applicationID, group)
+ return gt.queueTracker.canRunApp(hierarchy, applicationID, group)
}
diff --git a/pkg/scheduler/ugm/group_tracker_test.go
b/pkg/scheduler/ugm/group_tracker_test.go
index 4a8f3563..c969113a 100644
--- a/pkg/scheduler/ugm/group_tracker_test.go
+++ b/pkg/scheduler/ugm/group_tracker_test.go
@@ -40,36 +40,36 @@ func TestGTIncreaseTrackedResource(t *testing.T) {
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage1)
}
- result := groupTracker.increaseTrackedResource(queuePath1, TestApp1,
usage1, user.User)
+ result := groupTracker.increaseTrackedResource(hierarchy1, TestApp1,
usage1, user.User)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v", queuePath1, TestApp1, usage1)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v", hierarchy1, TestApp1, usage1)
}
usage2, err := resources.NewResourceFromConf(map[string]string{"mem":
"20M", "vcore": "20"})
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage2)
}
- result = groupTracker.increaseTrackedResource(queuePath2, TestApp2,
usage2, user.User)
+ result = groupTracker.increaseTrackedResource(hierarchy2, TestApp2,
usage2, user.User)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v", queuePath2, TestApp2, usage2)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v", hierarchy2, TestApp2, usage2)
}
usage3, err := resources.NewResourceFromConf(map[string]string{"mem":
"30M", "vcore": "30"})
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage3)
}
- result = groupTracker.increaseTrackedResource(queuePath3, TestApp3,
usage3, user.User)
+ result = groupTracker.increaseTrackedResource(hierarchy3, TestApp3,
usage3, user.User)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v", queuePath3, TestApp3, usage3)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v", hierarchy3, TestApp3, usage3)
}
usage4, err := resources.NewResourceFromConf(map[string]string{"mem":
"20M", "vcore": "20"})
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage3)
}
- result = groupTracker.increaseTrackedResource(queuePath4, TestApp4,
usage4, user.User)
+ result = groupTracker.increaseTrackedResource(hierarchy4, TestApp4,
usage4, user.User)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v", queuePath4, TestApp4, usage4)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v", hierarchy4, TestApp4, usage4)
}
actualResources := getGroupResource(groupTracker)
@@ -94,9 +94,9 @@ func TestGTDecreaseTrackedResource(t *testing.T) {
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage1)
}
- result := groupTracker.increaseTrackedResource(queuePath1, TestApp1,
usage1, user.User)
+ result := groupTracker.increaseTrackedResource(hierarchy1, TestApp1,
usage1, user.User)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v", queuePath1, TestApp1, usage1)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v", hierarchy1, TestApp1, usage1)
}
assert.Equal(t, 1, len(groupTracker.getTrackedApplications()))
@@ -104,9 +104,9 @@ func TestGTDecreaseTrackedResource(t *testing.T) {
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage2)
}
- result = groupTracker.increaseTrackedResource(queuePath2, TestApp2,
usage2, user.User)
+ result = groupTracker.increaseTrackedResource(hierarchy2, TestApp2,
usage2, user.User)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v", queuePath2, TestApp2, usage2)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v", hierarchy2, TestApp2, usage2)
}
actualResources := getGroupResource(groupTracker)
@@ -120,15 +120,15 @@ func TestGTDecreaseTrackedResource(t *testing.T) {
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage3)
}
- removeQT, decreased := groupTracker.decreaseTrackedResource(queuePath1,
TestApp1, usage3, false)
+ removeQT, decreased := groupTracker.decreaseTrackedResource(hierarchy1,
TestApp1, usage3, false)
if !decreased {
- t.Fatalf("unable to decrease tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath1, TestApp1, usage3, err)
+ t.Fatalf("unable to decrease tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy1, TestApp1, usage3, err)
}
assert.Equal(t, removeQT, false, "wrong remove queue tracker value")
- removeQT, decreased = groupTracker.decreaseTrackedResource(queuePath2,
TestApp2, usage3, false)
+ removeQT, decreased = groupTracker.decreaseTrackedResource(hierarchy2,
TestApp2, usage3, false)
if !decreased {
- t.Fatalf("unable to decrease tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath2, TestApp2, usage3, err)
+ t.Fatalf("unable to decrease tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy2, TestApp2, usage3, err)
}
assert.Equal(t, removeQT, false, "wrong remove queue tracker value")
@@ -144,9 +144,9 @@ func TestGTDecreaseTrackedResource(t *testing.T) {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage3)
}
- removeQT, decreased = groupTracker.decreaseTrackedResource(queuePath1,
TestApp1, usage4, true)
+ removeQT, decreased = groupTracker.decreaseTrackedResource(hierarchy1,
TestApp1, usage4, true)
if !decreased {
- t.Fatalf("unable to decrease tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath1, TestApp1, usage1, err)
+ t.Fatalf("unable to decrease tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy1, TestApp1, usage1, err)
}
assert.Equal(t, 1, len(groupTracker.getTrackedApplications()))
assert.Equal(t, removeQT, false, "wrong remove queue tracker value")
@@ -156,9 +156,9 @@ func TestGTDecreaseTrackedResource(t *testing.T) {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage3)
}
- removeQT, decreased = groupTracker.decreaseTrackedResource(queuePath2,
TestApp2, usage5, true)
+ removeQT, decreased = groupTracker.decreaseTrackedResource(hierarchy2,
TestApp2, usage5, true)
if !decreased {
- t.Fatalf("unable to decrease tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath2, TestApp2, usage2, err)
+ t.Fatalf("unable to decrease tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy2, TestApp2, usage2, err)
}
assert.Equal(t, 0, len(groupTracker.getTrackedApplications()))
assert.Equal(t, removeQT, true, "wrong remove queue tracker value")
@@ -167,6 +167,8 @@ func TestGTDecreaseTrackedResource(t *testing.T) {
func TestGTSetMaxLimits(t *testing.T) {
// Queue setup:
// root->parent->child1
+ // Initialize ugm
+ GetUserManager()
user := security.UserGroup{User: "test", Groups: []string{"test"}}
groupTracker := newGroupTracker(user.User)
usage1, err := resources.NewResourceFromConf(map[string]string{"mem":
"10M", "vcore": "10"})
@@ -174,24 +176,24 @@ func TestGTSetMaxLimits(t *testing.T) {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage1)
}
- result := groupTracker.increaseTrackedResource(queuePath1, TestApp1,
usage1, user.User)
+ result := groupTracker.increaseTrackedResource(hierarchy1, TestApp1,
usage1, user.User)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v", queuePath1, TestApp1, usage1)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v", hierarchy1, TestApp1, usage1)
}
- groupTracker.setLimits(queuePath1, resources.Multiply(usage1, 5), 5)
- groupTracker.setLimits("root.parent", resources.Multiply(usage1, 10),
10)
+ groupTracker.setLimits(hierarchy1, resources.Multiply(usage1, 5), 5)
+ groupTracker.setLimits(hierarchy5, resources.Multiply(usage1, 10), 10)
- result = groupTracker.increaseTrackedResource(queuePath1, TestApp2,
usage1, user.User)
+ result = groupTracker.increaseTrackedResource(hierarchy1, TestApp2,
usage1, user.User)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v", queuePath1, TestApp2, usage1)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v", hierarchy1, TestApp2, usage1)
}
- result = groupTracker.increaseTrackedResource(queuePath1, TestApp3,
usage1, user.User)
+ result = groupTracker.increaseTrackedResource(hierarchy1, TestApp3,
usage1, user.User)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v", queuePath1, TestApp2, usage1)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v", hierarchy1, TestApp3, usage1)
}
- groupTracker.setLimits(queuePath1, usage1, 1)
- groupTracker.setLimits("root.parent", usage1, 1)
+ groupTracker.setLimits(hierarchy1, usage1, 1)
+ groupTracker.setLimits(hierarchy5, usage1, 1)
}
func getGroupResource(gt *GroupTracker) map[string]*resources.Resource {
diff --git a/pkg/scheduler/ugm/manager.go b/pkg/scheduler/ugm/manager.go
index bbbd37f0..ceb3ba21 100644
--- a/pkg/scheduler/ugm/manager.go
+++ b/pkg/scheduler/ugm/manager.go
@@ -20,6 +20,7 @@ package ugm
import (
"fmt"
+ "strings"
"sync"
"go.uber.org/zap"
@@ -92,7 +93,7 @@ func (m *Manager) IncreaseTrackedResource(queuePath,
applicationID string, usage
if !userTracker.hasGroupForApp(applicationID) {
m.ensureGroupTrackerForApp(queuePath, applicationID, user)
}
- return userTracker.increaseTrackedResource(queuePath, applicationID,
usage)
+ return userTracker.increaseTrackedResource(strings.Split(queuePath,
configs.DOT), applicationID, usage)
}
// DecreaseTrackedResource Decrease the resource usage for the given user
group and queue path combination.
@@ -106,6 +107,7 @@ func (m *Manager) DecreaseTrackedResource(queuePath,
applicationID string, usage
zap.String("application", applicationID),
zap.Stringer("resource", usage),
zap.Bool("removeApp", removeApp))
+ hierarchy := strings.Split(queuePath, configs.DOT)
if queuePath == common.Empty || applicationID == common.Empty || usage
== nil || user.User == common.Empty {
log.Log(log.SchedUGM).Debug("Mandatory parameters are missing
to decrease the resource usage")
return false
@@ -126,7 +128,7 @@ func (m *Manager) DecreaseTrackedResource(queuePath,
applicationID string, usage
zap.String("tracked group", appGroup),
zap.Stringer("resource", usage),
zap.Bool("removeApp", removeApp))
- removeQT, decreased := userTracker.decreaseTrackedResource(queuePath,
applicationID, usage, removeApp)
+ removeQT, decreased := userTracker.decreaseTrackedResource(hierarchy,
applicationID, usage, removeApp)
if !decreased {
return decreased
}
@@ -152,7 +154,7 @@ func (m *Manager) DecreaseTrackedResource(queuePath,
applicationID string, usage
zap.String("application", applicationID),
zap.Stringer("resource", usage),
zap.Bool("removeApp", removeApp))
- removeQT, decreased = groupTracker.decreaseTrackedResource(queuePath,
applicationID, usage, removeApp)
+ removeQT, decreased = groupTracker.decreaseTrackedResource(hierarchy,
applicationID, usage, removeApp)
if !decreased {
return decreased
}
@@ -317,6 +319,7 @@ func (m *Manager) UpdateConfig(config configs.QueueConfig,
queuePath string) err
func (m *Manager) internalProcessConfig(cur configs.QueueConfig, queuePath
string, newUserLimits map[string]map[string]*LimitConfig, newGroupLimits
map[string]map[string]*LimitConfig,
newUserWildCardLimitsConfig map[string]*LimitConfig,
newGroupWildCardLimitsConfig map[string]*LimitConfig, newConfiguredGroups
map[string][]string) error {
+ hierarchy := strings.Split(queuePath, configs.DOT)
// Traverse limits of specific queue path
for _, limit := range cur.Limits {
var maxResource *resources.Resource
@@ -343,7 +346,7 @@ func (m *Manager) internalProcessConfig(cur
configs.QueueConfig, queuePath strin
newUserWildCardLimitsConfig[queuePath] =
limitConfig
continue
}
- if err := m.setUserLimits(user, limitConfig,
queuePath); err != nil {
+ if err := m.setUserLimits(user, limitConfig,
hierarchy); err != nil {
return err
}
if _, ok := newUserLimits[queuePath]; !ok {
@@ -361,7 +364,7 @@ func (m *Manager) internalProcessConfig(cur
configs.QueueConfig, queuePath strin
zap.String("queue path", queuePath),
zap.Uint64("max application",
limit.MaxApplications),
zap.Any("max resources", limit.MaxResources))
- if err := m.setGroupLimits(group, limitConfig,
queuePath); err != nil {
+ if err := m.setGroupLimits(group, limitConfig,
hierarchy); err != nil {
return err
}
if _, ok := newGroupLimits[queuePath]; !ok {
@@ -402,11 +405,12 @@ func (m *Manager) clearEarlierSetLimits(newUserLimits
map[string]map[string]*Lim
// by comparing with the existing config. Reset earlier usage only config set
earlier but not now
func (m *Manager) clearEarlierSetUserLimits(newUserLimits
map[string]map[string]*LimitConfig) {
for queuePath, limitConfig := range m.userLimits {
+ hierarchy := strings.Split(queuePath, configs.DOT)
// Is queue path exists?
if newUserLimit, ok := newUserLimits[queuePath]; !ok {
for u := range limitConfig {
if ut, utExists := m.userTrackers[u]; utExists {
- m.resetUserEarlierUsage(ut, queuePath)
+ m.resetUserEarlierUsage(ut, hierarchy)
}
}
} else {
@@ -414,7 +418,7 @@ func (m *Manager) clearEarlierSetUserLimits(newUserLimits
map[string]map[string]
for u := range limitConfig {
if _, ulExists := newUserLimit[u]; !ulExists {
if ut, utExists := m.userTrackers[u];
utExists {
- m.resetUserEarlierUsage(ut,
queuePath)
+ m.resetUserEarlierUsage(ut,
hierarchy)
}
}
}
@@ -425,20 +429,20 @@ func (m *Manager) clearEarlierSetUserLimits(newUserLimits
map[string]map[string]
// resetUserEarlierUsage Clear or reset earlier usage only when user already
tracked for the queue path.
// Reset the max apps and max resources to default, unlink the end leaf queue
of queue path from its immediate parent and
// eventually remove user tracker object itself from ugm if it can be removed.
-func (m *Manager) resetUserEarlierUsage(ut *UserTracker, queuePath string) {
+func (m *Manager) resetUserEarlierUsage(ut *UserTracker, hierarchy []string) {
// Is this user already tracked for the queue path?
- if ut.IsQueuePathTrackedCompletely(queuePath) {
+ if ut.IsQueuePathTrackedCompletely(hierarchy) {
log.Log(log.SchedUGM).Debug("Need to clear earlier set configs
for user",
zap.String("user", ut.userName),
- zap.String("queue path", queuePath))
- ut.setLimits(queuePath, nil, 0)
+ zap.Strings("queue path", hierarchy))
+ ut.setLimits(hierarchy, nil, 0)
// Is there any running applications in end queue of this queue
path? If not, then remove the linkage between end queue and its immediate parent
- if ut.IsUnlinkRequired(queuePath) {
- ut.UnlinkQT(queuePath)
+ if ut.IsUnlinkRequired(hierarchy) {
+ ut.UnlinkQT(hierarchy)
}
log.Log(log.SchedUGM).Debug("Cleared earlier set limit configs
for user",
zap.String("user", ut.userName),
- zap.String("queue path", queuePath))
+ zap.Strings("queue path", hierarchy))
if ut.canBeRemoved() {
delete(m.userTrackers, ut.userName)
}
@@ -449,11 +453,12 @@ func (m *Manager) resetUserEarlierUsage(ut *UserTracker,
queuePath string) {
// by comparing with the existing config. Reset earlier usage only config set
earlier but not now
func (m *Manager) clearEarlierSetGroupLimits(newGroupLimits
map[string]map[string]*LimitConfig) {
for queuePath, limitConfig := range m.groupLimits {
+ hierarchy := strings.Split(queuePath, configs.DOT)
// Is queue path exists?
if newGroupLimit, ok := newGroupLimits[queuePath]; !ok {
for g := range limitConfig {
if gt, gtExists := m.groupTrackers[g]; gtExists
{
- m.resetGroupEarlierUsage(gt, queuePath)
+ m.resetGroupEarlierUsage(gt, hierarchy)
}
}
} else {
@@ -461,7 +466,7 @@ func (m *Manager) clearEarlierSetGroupLimits(newGroupLimits
map[string]map[strin
for g := range limitConfig {
if _, glExists := newGroupLimit[g]; !glExists {
if gt, gtExists := m.groupTrackers[g];
gtExists {
- m.resetGroupEarlierUsage(gt,
queuePath)
+ m.resetGroupEarlierUsage(gt,
hierarchy)
}
}
}
@@ -473,24 +478,24 @@ func (m *Manager)
clearEarlierSetGroupLimits(newGroupLimits map[string]map[strin
// Decrease the group usage and collect the list of applications for which
user app group linkage needs to be broken.
// Reset the max apps and max resources to default, unlink the end leaf queue
of queue path from its immediate parent and
// eventually remove group tracker object itself from ugm if it can be removed.
-func (m *Manager) resetGroupEarlierUsage(gt *GroupTracker, queuePath string) {
- if gt.IsQueuePathTrackedCompletely(queuePath) {
+func (m *Manager) resetGroupEarlierUsage(gt *GroupTracker, hierarchy []string)
{
+ if gt.IsQueuePathTrackedCompletely(hierarchy) {
log.Log(log.SchedUGM).Debug("Need to clear earlier set configs
for group",
zap.String("group", gt.groupName),
- zap.String("queue path", queuePath))
- appUsersMap := gt.decreaseAllTrackedResourceUsage(queuePath)
+ zap.Strings("queue path", hierarchy))
+ appUsersMap := gt.decreaseAllTrackedResourceUsage(hierarchy)
for app, u := range appUsersMap {
ut := m.userTrackers[u]
delete(ut.appGroupTrackers, app)
}
- gt.setLimits(queuePath, nil, 0)
+ gt.setLimits(hierarchy, nil, 0)
// Is there any running applications in end queue of this queue
path? If not, then remove the linkage between end queue and its immediate parent
- if gt.IsUnlinkRequired(queuePath) {
- gt.UnlinkQT(queuePath)
+ if gt.IsUnlinkRequired(hierarchy) {
+ gt.UnlinkQT(hierarchy)
}
log.Log(log.SchedUGM).Debug("Cleared earlier set limit configs
for group",
zap.String("group", gt.groupName),
- zap.String("queue path", queuePath))
+ zap.Strings("queue path", hierarchy))
if gt.canBeRemoved() {
delete(m.groupTrackers, gt.groupName)
}
@@ -508,43 +513,43 @@ func (m *Manager) replaceLimitConfigs(newUserLimits
map[string]map[string]*Limit
m.configuredGroups = newConfiguredGroups
}
-func (m *Manager) setUserLimits(user string, limitConfig *LimitConfig,
queuePath string) error {
+func (m *Manager) setUserLimits(user string, limitConfig *LimitConfig,
hierarchy []string) error {
m.Lock()
defer m.Unlock()
log.Log(log.SchedUGM).Debug("Setting user limits",
zap.String("user", user),
- zap.String("queue path", queuePath),
+ zap.Strings("queue path", hierarchy),
zap.Uint64("max application", limitConfig.maxApplications),
zap.Any("max resources", limitConfig.maxResources))
userTracker, ok := m.userTrackers[user]
if !ok {
log.Log(log.SchedUGM).Debug("User tracker does not exist.
Creating user tracker object to set the limit configuration",
zap.String("user", user),
- zap.String("queue path", queuePath))
+ zap.Strings("queue path", hierarchy))
userTracker = newUserTracker(user)
m.userTrackers[user] = userTracker
}
- userTracker.setLimits(queuePath, limitConfig.maxResources,
limitConfig.maxApplications)
+ userTracker.setLimits(hierarchy, limitConfig.maxResources,
limitConfig.maxApplications)
return nil
}
-func (m *Manager) setGroupLimits(group string, limitConfig *LimitConfig,
queuePath string) error {
+func (m *Manager) setGroupLimits(group string, limitConfig *LimitConfig,
hierarchy []string) error {
m.Lock()
defer m.Unlock()
log.Log(log.SchedUGM).Debug("Setting group limits",
zap.String("group", group),
- zap.String("queue path", queuePath),
+ zap.Strings("queue path", hierarchy),
zap.Uint64("max application", limitConfig.maxApplications),
zap.Any("max resources", limitConfig.maxResources))
groupTracker, ok := m.groupTrackers[group]
if !ok {
log.Log(log.SchedUGM).Debug("Group tracker does not exist.
Creating group tracker object to set the limit configuration",
zap.String("group", group),
- zap.String("queue path", queuePath))
+ zap.Strings("queue path", hierarchy))
groupTracker = newGroupTracker(group)
m.groupTrackers[group] = groupTracker
}
- groupTracker.setLimits(queuePath, limitConfig.maxResources,
limitConfig.maxApplications)
+ groupTracker.setLimits(hierarchy, limitConfig.maxResources,
limitConfig.maxApplications)
return nil
}
@@ -584,8 +589,9 @@ func (m *Manager) getGroupWildCardLimitsConfig(queuePath
string) *LimitConfig {
// Headroom calculates the headroom for this specific application that runs as
the user and group.
func (m *Manager) Headroom(queuePath, applicationID string, user
security.UserGroup) *resources.Resource {
+ hierarchy := strings.Split(queuePath, configs.DOT)
userTracker := m.getUserTracker(user.User)
- userHeadroom := userTracker.headroom(queuePath)
+ userHeadroom := userTracker.headroom(hierarchy)
log.Log(log.SchedUGM).Debug("Calculated headroom for user",
zap.String("user", user.User),
zap.String("queue path", queuePath),
@@ -603,7 +609,7 @@ func (m *Manager) Headroom(queuePath, applicationID string,
user security.UserGr
if groupTracker == nil {
return userHeadroom
}
- groupHeadroom := groupTracker.headroom(queuePath)
+ groupHeadroom := groupTracker.headroom(hierarchy)
log.Log(log.SchedUGM).Debug("Calculated headroom for group",
zap.String("group", appGroup),
zap.String("queue path", queuePath),
@@ -613,8 +619,9 @@ func (m *Manager) Headroom(queuePath, applicationID string,
user security.UserGr
// CanRunApp checks the maxApplications for this specific application that
runs as the user and group.
func (m *Manager) CanRunApp(queuePath, applicationID string, user
security.UserGroup) bool {
+ hierarchy := strings.Split(queuePath, configs.DOT)
userTracker := m.getUserTracker(user.User)
- userCanRunApp := userTracker.canRunApp(queuePath, applicationID)
+ userCanRunApp := userTracker.canRunApp(hierarchy, applicationID)
log.Log(log.SchedUGM).Debug("Check whether user can run app",
zap.String("user", user.User),
zap.String("queue path", queuePath),
@@ -632,7 +639,7 @@ func (m *Manager) CanRunApp(queuePath, applicationID
string, user security.UserG
if groupTracker == nil {
return userCanRunApp
}
- groupCanRunApp := groupTracker.canRunApp(queuePath, applicationID)
+ groupCanRunApp := groupTracker.canRunApp(hierarchy, applicationID)
log.Log(log.SchedUGM).Debug("Check whether group can run app",
zap.String("group", appGroup),
zap.String("queue path", queuePath),
diff --git a/pkg/scheduler/ugm/user_tracker.go
b/pkg/scheduler/ugm/user_tracker.go
index 1a4e2c81..f2361cd1 100644
--- a/pkg/scheduler/ugm/user_tracker.go
+++ b/pkg/scheduler/ugm/user_tracker.go
@@ -19,13 +19,11 @@
package ugm
import (
- "strings"
"sync"
"go.uber.org/zap"
"github.com/apache/yunikorn-core/pkg/common"
- "github.com/apache/yunikorn-core/pkg/common/configs"
"github.com/apache/yunikorn-core/pkg/common/resources"
"github.com/apache/yunikorn-core/pkg/log"
"github.com/apache/yunikorn-core/pkg/webservice/dao"
@@ -54,24 +52,23 @@ func newUserTracker(user string) *UserTracker {
return userTracker
}
-func (ut *UserTracker) increaseTrackedResource(queuePath, applicationID
string, usage *resources.Resource) bool {
+func (ut *UserTracker) increaseTrackedResource(hierarchy []string,
applicationID string, usage *resources.Resource) bool {
ut.Lock()
defer ut.Unlock()
- hierarchy := strings.Split(queuePath, configs.DOT)
increased := ut.queueTracker.increaseTrackedResource(hierarchy,
applicationID, user, usage)
if increased {
gt := ut.appGroupTrackers[applicationID]
log.Log(log.SchedUGM).Debug("Increasing resource usage for
group",
zap.String("group", gt.getName()),
- zap.String("queue path", queuePath),
+ zap.Strings("queue path", hierarchy),
zap.String("application", applicationID),
zap.Stringer("resource", usage))
- increasedGroupUsage := gt.increaseTrackedResource(queuePath,
applicationID, usage, ut.userName)
+ increasedGroupUsage := gt.increaseTrackedResource(hierarchy,
applicationID, usage, ut.userName)
if !increasedGroupUsage {
_, decreased :=
ut.queueTracker.decreaseTrackedResource(hierarchy, applicationID, usage, false)
if !decreased {
log.Log(log.SchedUGM).Error("User resource
usage rollback has failed",
- zap.String("queue path", queuePath),
+ zap.Strings("queue path", hierarchy),
zap.String("application",
applicationID),
zap.String("user", ut.userName))
}
@@ -81,13 +78,13 @@ func (ut *UserTracker) increaseTrackedResource(queuePath,
applicationID string,
return increased
}
-func (ut *UserTracker) decreaseTrackedResource(queuePath, applicationID
string, usage *resources.Resource, removeApp bool) (bool, bool) {
+func (ut *UserTracker) decreaseTrackedResource(hierarchy []string,
applicationID string, usage *resources.Resource, removeApp bool) (bool, bool) {
ut.Lock()
defer ut.Unlock()
if removeApp {
delete(ut.appGroupTrackers, applicationID)
}
- return ut.queueTracker.decreaseTrackedResource(strings.Split(queuePath,
configs.DOT), applicationID, usage, removeApp)
+ return ut.queueTracker.decreaseTrackedResource(hierarchy,
applicationID, usage, removeApp)
}
func (ut *UserTracker) hasGroupForApp(applicationID string) bool {
@@ -118,16 +115,16 @@ func (ut *UserTracker) getTrackedApplications()
map[string]*GroupTracker {
return ut.appGroupTrackers
}
-func (ut *UserTracker) setLimits(queuePath string, resource
*resources.Resource, maxApps uint64) {
+func (ut *UserTracker) setLimits(hierarchy []string, resource
*resources.Resource, maxApps uint64) {
ut.Lock()
defer ut.Unlock()
- ut.queueTracker.setLimit(strings.Split(queuePath, configs.DOT),
resource, maxApps)
+ ut.queueTracker.setLimit(hierarchy, resource, maxApps)
}
-func (ut *UserTracker) headroom(queuePath string) *resources.Resource {
+func (ut *UserTracker) headroom(hierarchy []string) *resources.Resource {
ut.Lock()
defer ut.Unlock()
- return ut.queueTracker.headroom(strings.Split(queuePath, configs.DOT),
user)
+ return ut.queueTracker.headroom(hierarchy, user)
}
func (ut *UserTracker) GetUserResourceUsageDAOInfo()
*dao.UserResourceUsageDAOInfo {
@@ -146,22 +143,22 @@ func (ut *UserTracker) GetUserResourceUsageDAOInfo()
*dao.UserResourceUsageDAOIn
return userResourceUsage
}
-func (ut *UserTracker) IsQueuePathTrackedCompletely(queuePath string) bool {
+func (ut *UserTracker) IsQueuePathTrackedCompletely(hierarchy []string) bool {
ut.RLock()
defer ut.RUnlock()
- return
ut.queueTracker.IsQueuePathTrackedCompletely(strings.Split(queuePath,
configs.DOT))
+ return ut.queueTracker.IsQueuePathTrackedCompletely(hierarchy)
}
-func (ut *UserTracker) IsUnlinkRequired(queuePath string) bool {
+func (ut *UserTracker) IsUnlinkRequired(hierarchy []string) bool {
ut.RLock()
defer ut.RUnlock()
- return ut.queueTracker.IsUnlinkRequired(strings.Split(queuePath,
configs.DOT))
+ return ut.queueTracker.IsUnlinkRequired(hierarchy)
}
-func (ut *UserTracker) UnlinkQT(queuePath string) bool {
+func (ut *UserTracker) UnlinkQT(hierarchy []string) bool {
ut.RLock()
defer ut.RUnlock()
- return ut.queueTracker.UnlinkQT(strings.Split(queuePath, configs.DOT))
+ return ut.queueTracker.UnlinkQT(hierarchy)
}
func (ut *UserTracker) canBeRemoved() bool {
@@ -170,8 +167,8 @@ func (ut *UserTracker) canBeRemoved() bool {
return ut.queueTracker.canBeRemoved()
}
-func (ut *UserTracker) canRunApp(queuePath, applicationID string) bool {
+func (ut *UserTracker) canRunApp(hierarchy []string, applicationID string)
bool {
ut.Lock()
defer ut.Unlock()
- return ut.queueTracker.canRunApp(strings.Split(queuePath, configs.DOT),
applicationID, user)
+ return ut.queueTracker.canRunApp(hierarchy, applicationID, user)
}
diff --git a/pkg/scheduler/ugm/user_tracker_test.go
b/pkg/scheduler/ugm/user_tracker_test.go
index bf9cc143..4edece6b 100644
--- a/pkg/scheduler/ugm/user_tracker_test.go
+++ b/pkg/scheduler/ugm/user_tracker_test.go
@@ -39,20 +39,28 @@ const (
queuePath4 = "root.parent.child12"
)
+var hierarchy1 = []string{"root", "parent", "child1"}
+var hierarchy2 = []string{"root", "parent", "child2"}
+var hierarchy3 = []string{"root", "parent", "child1", "child12"}
+var hierarchy4 = []string{"root", "parent", "child12"}
+var hierarchy5 = []string{"root", "parent"}
+
func TestIncreaseTrackedResource(t *testing.T) {
// Queue setup:
// root->parent->child1->child12
// root->parent->child2
// root->parent->child12 (similar name like above leaf queue, but it is
being treated differently as similar names are allowed)
+ // Initialize ugm
+ GetUserManager()
user := security.UserGroup{User: "test", Groups: []string{"test"}}
userTracker := newUserTracker(user.User)
usage1, err := resources.NewResourceFromConf(map[string]string{"mem":
"10M", "vcore": "10"})
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage1)
}
- result := userTracker.increaseTrackedResource(queuePath1, TestApp1,
usage1)
+ result := userTracker.increaseTrackedResource(hierarchy1, TestApp1,
usage1)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v", queuePath1, TestApp1, usage1)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v", hierarchy1, TestApp1, usage1)
}
groupTracker := newGroupTracker(user.User)
userTracker.setGroupForApp(TestApp1, groupTracker)
@@ -61,9 +69,9 @@ func TestIncreaseTrackedResource(t *testing.T) {
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage2)
}
- result = userTracker.increaseTrackedResource(queuePath2, TestApp2,
usage2)
+ result = userTracker.increaseTrackedResource(hierarchy2, TestApp2,
usage2)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath2, TestApp2, usage2, err)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy2, TestApp2, usage2, err)
}
userTracker.setGroupForApp(TestApp2, groupTracker)
@@ -71,9 +79,9 @@ func TestIncreaseTrackedResource(t *testing.T) {
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage3)
}
- result = userTracker.increaseTrackedResource(queuePath3, TestApp3,
usage3)
+ result = userTracker.increaseTrackedResource(hierarchy3, TestApp3,
usage3)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath3, TestApp3, usage3, err)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy3, TestApp3, usage3, err)
}
userTracker.setGroupForApp(TestApp3, groupTracker)
@@ -81,9 +89,9 @@ func TestIncreaseTrackedResource(t *testing.T) {
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage3)
}
- result = userTracker.increaseTrackedResource(queuePath4, TestApp4,
usage4)
+ result = userTracker.increaseTrackedResource(hierarchy4, TestApp4,
usage4)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath4, TestApp4, usage4, err)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy4, TestApp4, usage4, err)
}
userTracker.setGroupForApp(TestApp4, groupTracker)
@@ -104,6 +112,8 @@ func TestDecreaseTrackedResource(t *testing.T) {
// Queue setup:
// root->parent->child1
// root->parent->child2
+ // Initialize ugm
+ GetUserManager()
user := security.UserGroup{User: "test", Groups: []string{"test"}}
userTracker := newUserTracker(user.User)
@@ -111,9 +121,9 @@ func TestDecreaseTrackedResource(t *testing.T) {
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage1)
}
- result := userTracker.increaseTrackedResource(queuePath1, TestApp1,
usage1)
+ result := userTracker.increaseTrackedResource(hierarchy1, TestApp1,
usage1)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath1, TestApp1, usage1, err)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy1, TestApp1, usage1, err)
}
groupTracker := newGroupTracker(user.User)
userTracker.setGroupForApp(TestApp1, groupTracker)
@@ -123,9 +133,9 @@ func TestDecreaseTrackedResource(t *testing.T) {
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage2)
}
- result = userTracker.increaseTrackedResource(queuePath2, TestApp2,
usage2)
+ result = userTracker.increaseTrackedResource(hierarchy2, TestApp2,
usage2)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath2, TestApp2, usage2, err)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy2, TestApp2, usage2, err)
}
userTracker.setGroupForApp(TestApp2, groupTracker)
actualResources := getUserResource(userTracker)
@@ -140,15 +150,15 @@ func TestDecreaseTrackedResource(t *testing.T) {
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage3)
}
- removeQT, decreased := userTracker.decreaseTrackedResource(queuePath1,
TestApp1, usage3, false)
+ removeQT, decreased := userTracker.decreaseTrackedResource(hierarchy1,
TestApp1, usage3, false)
if !decreased {
- t.Fatalf("unable to decrease tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath1, TestApp1, usage3, err)
+ t.Fatalf("unable to decrease tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy1, TestApp1, usage3, err)
}
assert.Equal(t, removeQT, false, "wrong remove queue tracker value")
- removeQT, decreased = userTracker.decreaseTrackedResource(queuePath2,
TestApp2, usage3, false)
+ removeQT, decreased = userTracker.decreaseTrackedResource(hierarchy2,
TestApp2, usage3, false)
if !decreased {
- t.Fatalf("unable to decrease tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath2, TestApp2, usage3, err)
+ t.Fatalf("unable to decrease tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy2, TestApp2, usage3, err)
}
actualResources1 := getUserResource(userTracker)
@@ -163,9 +173,9 @@ func TestDecreaseTrackedResource(t *testing.T) {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage3)
}
- removeQT, decreased = userTracker.decreaseTrackedResource(queuePath1,
TestApp1, usage4, true)
+ removeQT, decreased = userTracker.decreaseTrackedResource(hierarchy1,
TestApp1, usage4, true)
if !decreased {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath1, TestApp1, usage1, err)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy1, TestApp1, usage1, err)
}
assert.Equal(t, 1, len(userTracker.getTrackedApplications()))
assert.Equal(t, removeQT, false, "wrong remove queue tracker value")
@@ -174,9 +184,9 @@ func TestDecreaseTrackedResource(t *testing.T) {
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage5)
}
- removeQT, decreased = userTracker.decreaseTrackedResource(queuePath2,
TestApp2, usage5, true)
+ removeQT, decreased = userTracker.decreaseTrackedResource(hierarchy2,
TestApp2, usage5, true)
if !decreased {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath2, TestApp2, usage2, err)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy2, TestApp2, usage2, err)
}
assert.Equal(t, 0, len(userTracker.getTrackedApplications()))
assert.Equal(t, removeQT, true, "wrong remove queue tracker value")
@@ -185,31 +195,33 @@ func TestDecreaseTrackedResource(t *testing.T) {
func TestSetMaxLimits(t *testing.T) {
// Queue setup:
// root->parent->child1
+ // Initialize ugm
+ GetUserManager()
user := security.UserGroup{User: "test", Groups: []string{"test"}}
userTracker := newUserTracker(user.User)
usage1, err := resources.NewResourceFromConf(map[string]string{"mem":
"10M", "vcore": "10"})
if err != nil {
t.Errorf("new resource create returned error or wrong resource:
error %t, res %v", err, usage1)
}
- result := userTracker.increaseTrackedResource(queuePath1, TestApp1,
usage1)
+ result := userTracker.increaseTrackedResource(hierarchy1, TestApp1,
usage1)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v, error %t", queuePath1, TestApp1, usage1, err)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v, error %t", hierarchy1, TestApp1, usage1, err)
}
- userTracker.setLimits(queuePath1, resources.Multiply(usage1, 5), 5)
- userTracker.setLimits("root.parent", resources.Multiply(usage1, 10), 10)
+ userTracker.setLimits(hierarchy1, resources.Multiply(usage1, 5), 5)
+ userTracker.setLimits(hierarchy5, resources.Multiply(usage1, 10), 10)
- result = userTracker.increaseTrackedResource(queuePath1, TestApp1,
usage1)
+ result = userTracker.increaseTrackedResource(hierarchy1, TestApp1,
usage1)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v", queuePath1, TestApp1, usage1)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v", hierarchy1, TestApp1, usage1)
}
- result = userTracker.increaseTrackedResource(queuePath1, TestApp2,
usage1)
+ result = userTracker.increaseTrackedResource(hierarchy1, TestApp2,
usage1)
if !result {
- t.Fatalf("unable to increase tracked resource: queuepath %s,
app %s, res %v", queuePath1, TestApp2, usage1)
+ t.Fatalf("unable to increase tracked resource: queuepath %+q,
app %s, res %v", hierarchy1, TestApp2, usage1)
}
- userTracker.setLimits(queuePath1, usage1, 1)
- userTracker.setLimits("root.parent", usage1, 1)
+ userTracker.setLimits(hierarchy1, usage1, 1)
+ userTracker.setLimits(hierarchy5, usage1, 1)
}
func getUserResource(ut *UserTracker) map[string]*resources.Resource {
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
