github.com/kaisenlinux/docker@v0.0.0-20230510090727-ea55db55fac7/swarmkit/api/genericresource/resource_management_test.go (about)

     1  package genericresource
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/docker/swarmkit/api"
     7  	"github.com/stretchr/testify/assert"
     8  )
     9  
    10  func TestClaimSingleDiscrete(t *testing.T) {
    11  	var nodeRes, taskAssigned, taskReservations []*api.GenericResource
    12  
    13  	nodeRes = append(nodeRes, NewDiscrete("apple", 3))
    14  	taskReservations = append(taskReservations, NewDiscrete("apple", 2))
    15  
    16  	err := Claim(&nodeRes, &taskAssigned, taskReservations)
    17  	assert.NoError(t, err)
    18  
    19  	assert.Len(t, nodeRes, 1)
    20  	assert.Len(t, taskAssigned, 1)
    21  
    22  	assert.Equal(t, int64(1), nodeRes[0].GetDiscreteResourceSpec().Value)
    23  	assert.Equal(t, int64(2), taskAssigned[0].GetDiscreteResourceSpec().Value)
    24  }
    25  
    26  func TestClaimMultipleDiscrete(t *testing.T) {
    27  	var nodeRes, taskAssigned, taskReservations []*api.GenericResource
    28  
    29  	nodeRes = append(nodeRes, NewDiscrete("apple", 3))
    30  	nodeRes = append(nodeRes, NewDiscrete("orange", 4))
    31  	nodeRes = append(nodeRes, NewDiscrete("banana", 2))
    32  	nodeRes = append(nodeRes, NewDiscrete("cake", 1))
    33  
    34  	// cake and banana should not be taken
    35  	taskReservations = append(taskReservations, NewDiscrete("orange", 4))
    36  	taskReservations = append(taskReservations, NewDiscrete("apple", 2))
    37  
    38  	err := Claim(&nodeRes, &taskAssigned, taskReservations)
    39  	assert.NoError(t, err)
    40  
    41  	assert.Len(t, nodeRes, 3) // oranges isn't present anymore
    42  	assert.Len(t, taskAssigned, 2)
    43  
    44  	apples := GetResource("apple", taskAssigned)
    45  	oranges := GetResource("orange", taskAssigned)
    46  	assert.Len(t, apples, 1)
    47  	assert.Len(t, oranges, 1)
    48  
    49  	assert.Equal(t, int64(2), apples[0].GetDiscreteResourceSpec().Value)
    50  	assert.Equal(t, int64(4), oranges[0].GetDiscreteResourceSpec().Value)
    51  }
    52  
    53  func TestClaimSingleStr(t *testing.T) {
    54  	var nodeRes, taskAssigned, taskReservations []*api.GenericResource
    55  
    56  	nodeRes = append(nodeRes, NewSet("apple", "red", "orange", "blue", "green")...)
    57  	taskReservations = append(taskReservations, NewDiscrete("apple", 2))
    58  
    59  	err := Claim(&nodeRes, &taskAssigned, taskReservations)
    60  	assert.NoError(t, err)
    61  
    62  	assert.Len(t, nodeRes, 2)
    63  	assert.Len(t, taskAssigned, 2)
    64  
    65  	for _, k := range []string{"red", "orange"} {
    66  		assert.True(t, HasResource(NewString("apple", k), taskAssigned))
    67  	}
    68  }
    69  
    70  func TestClaimMultipleStr(t *testing.T) {
    71  	var nodeRes, taskAssigned, taskReservations []*api.GenericResource
    72  
    73  	nodeRes = append(nodeRes, NewSet("apple", "red", "orange", "blue", "green")...)
    74  	nodeRes = append(nodeRes, NewSet("oranges", "red", "orange", "blue", "green")...)
    75  	nodeRes = append(nodeRes, NewSet("bananas", "red", "orange", "blue", "green")...)
    76  	taskReservations = append(taskReservations, NewDiscrete("oranges", 4))
    77  	taskReservations = append(taskReservations, NewDiscrete("apple", 2))
    78  
    79  	err := Claim(&nodeRes, &taskAssigned, taskReservations)
    80  	assert.NoError(t, err)
    81  
    82  	assert.Len(t, nodeRes, 6)
    83  	assert.Len(t, taskAssigned, 6)
    84  
    85  	apples := GetResource("apple", taskAssigned)
    86  	for _, k := range []string{"red", "orange"} {
    87  		assert.True(t, HasResource(NewString("apple", k), apples))
    88  	}
    89  
    90  	oranges := GetResource("oranges", taskAssigned)
    91  	for _, k := range []string{"red", "orange", "blue", "green"} {
    92  		assert.True(t, HasResource(NewString("oranges", k), oranges))
    93  	}
    94  }
    95  
    96  func TestReclaimSingleDiscrete(t *testing.T) {
    97  	var nodeRes, taskAssigned []*api.GenericResource
    98  
    99  	taskAssigned = append(taskAssigned, NewDiscrete("apple", 2))
   100  
   101  	err := reclaimResources(&nodeRes, taskAssigned)
   102  	assert.NoError(t, err)
   103  
   104  	assert.Len(t, nodeRes, 1)
   105  	assert.Equal(t, int64(2), nodeRes[0].GetDiscreteResourceSpec().Value)
   106  
   107  	err = reclaimResources(&nodeRes, taskAssigned)
   108  	assert.NoError(t, err)
   109  
   110  	assert.Len(t, nodeRes, 1)
   111  	assert.Equal(t, int64(4), nodeRes[0].GetDiscreteResourceSpec().Value)
   112  }
   113  
   114  func TestReclaimMultipleDiscrete(t *testing.T) {
   115  	var nodeRes, taskAssigned []*api.GenericResource
   116  
   117  	nodeRes = append(nodeRes, NewDiscrete("apple", 3))
   118  	nodeRes = append(nodeRes, NewDiscrete("banana", 2))
   119  
   120  	// cake and banana should not be taken
   121  	taskAssigned = append(taskAssigned, NewDiscrete("orange", 4))
   122  	taskAssigned = append(taskAssigned, NewDiscrete("apple", 2))
   123  
   124  	err := reclaimResources(&nodeRes, taskAssigned)
   125  	assert.NoError(t, err)
   126  
   127  	assert.Len(t, nodeRes, 3)
   128  
   129  	apples := GetResource("apple", nodeRes)
   130  	oranges := GetResource("orange", nodeRes)
   131  	bananas := GetResource("banana", nodeRes)
   132  	assert.Len(t, apples, 1)
   133  	assert.Len(t, oranges, 1)
   134  	assert.Len(t, bananas, 1)
   135  
   136  	assert.Equal(t, int64(5), apples[0].GetDiscreteResourceSpec().Value)
   137  	assert.Equal(t, int64(4), oranges[0].GetDiscreteResourceSpec().Value)
   138  	assert.Equal(t, int64(2), bananas[0].GetDiscreteResourceSpec().Value)
   139  }
   140  
   141  func TestReclaimSingleStr(t *testing.T) {
   142  	var nodeRes []*api.GenericResource
   143  	taskAssigned := NewSet("apple", "red", "orange")
   144  
   145  	err := reclaimResources(&nodeRes, taskAssigned)
   146  	assert.NoError(t, err)
   147  	assert.Len(t, nodeRes, 2)
   148  
   149  	for _, k := range []string{"red", "orange"} {
   150  		assert.True(t, HasResource(NewString("apple", k), nodeRes))
   151  	}
   152  
   153  	taskAssigned = NewSet("apple", "blue", "red")
   154  	err = reclaimResources(&nodeRes, taskAssigned)
   155  
   156  	assert.NoError(t, err)
   157  	assert.Len(t, nodeRes, 4)
   158  
   159  	for _, k := range []string{"red", "orange", "blue", "red"} {
   160  		assert.True(t, HasResource(NewString("apple", k), nodeRes))
   161  	}
   162  }
   163  
   164  func TestReclaimMultipleStr(t *testing.T) {
   165  	nodeRes := NewSet("orange", "green")
   166  	taskAssigned := NewSet("apple", "red", "orange")
   167  	taskAssigned = append(taskAssigned, NewSet("orange", "red", "orange")...)
   168  
   169  	err := reclaimResources(&nodeRes, taskAssigned)
   170  	assert.NoError(t, err)
   171  	assert.Len(t, nodeRes, 5)
   172  
   173  	apples := GetResource("apple", nodeRes)
   174  	oranges := GetResource("orange", nodeRes)
   175  	assert.Len(t, apples, 2)
   176  	assert.Len(t, oranges, 3)
   177  
   178  	for _, k := range []string{"red", "orange"} {
   179  		assert.True(t, HasResource(NewString("apple", k), apples))
   180  	}
   181  
   182  	for _, k := range []string{"red", "orange", "green"} {
   183  		assert.True(t, HasResource(NewString("orange", k), oranges))
   184  	}
   185  }
   186  
   187  func TestReclaimResources(t *testing.T) {
   188  	nodeRes := NewSet("orange", "green", "blue")
   189  	nodeRes = append(nodeRes, NewDiscrete("apple", 3))
   190  	nodeRes = append(nodeRes, NewSet("banana", "red", "orange", "green")...)
   191  	nodeRes = append(nodeRes, NewDiscrete("cake", 2))
   192  
   193  	taskAssigned := NewSet("orange", "red", "orange")
   194  	taskAssigned = append(taskAssigned, NewSet("grape", "red", "orange")...)
   195  	taskAssigned = append(taskAssigned, NewDiscrete("apple", 3))
   196  	taskAssigned = append(taskAssigned, NewDiscrete("coffe", 2))
   197  
   198  	err := reclaimResources(&nodeRes, taskAssigned)
   199  	assert.NoError(t, err)
   200  	assert.Len(t, nodeRes, 12)
   201  
   202  	apples := GetResource("apple", nodeRes)
   203  	oranges := GetResource("orange", nodeRes)
   204  	bananas := GetResource("banana", nodeRes)
   205  	cakes := GetResource("cake", nodeRes)
   206  	grapes := GetResource("grape", nodeRes)
   207  	coffe := GetResource("coffe", nodeRes)
   208  	assert.Len(t, apples, 1)
   209  	assert.Len(t, oranges, 4)
   210  	assert.Len(t, bananas, 3)
   211  	assert.Len(t, cakes, 1)
   212  	assert.Len(t, grapes, 2)
   213  	assert.Len(t, coffe, 1)
   214  
   215  	assert.Equal(t, int64(6), apples[0].GetDiscreteResourceSpec().Value)
   216  	assert.Equal(t, int64(2), cakes[0].GetDiscreteResourceSpec().Value)
   217  	assert.Equal(t, int64(2), coffe[0].GetDiscreteResourceSpec().Value)
   218  
   219  	for _, k := range []string{"red", "orange", "green", "blue"} {
   220  		assert.True(t, HasResource(NewString("orange", k), oranges))
   221  	}
   222  
   223  	for _, k := range []string{"red", "orange", "green"} {
   224  		assert.True(t, HasResource(NewString("banana", k), bananas))
   225  	}
   226  
   227  	for _, k := range []string{"red", "orange"} {
   228  		assert.True(t, HasResource(NewString("grape", k), grapes))
   229  	}
   230  }
   231  
   232  func TestSanitizeDiscrete(t *testing.T) {
   233  	var nodeRes, nodeAvailableResources []*api.GenericResource
   234  	nodeAvailableResources = append(nodeAvailableResources, NewDiscrete("orange", 4))
   235  
   236  	sanitize(nodeRes, &nodeAvailableResources)
   237  	assert.Len(t, nodeAvailableResources, 0)
   238  
   239  	nodeRes = append(nodeRes, NewDiscrete("orange", 6))
   240  	nodeAvailableResources = append(nodeAvailableResources, NewDiscrete("orange", 4))
   241  
   242  	sanitize(nodeRes, &nodeAvailableResources)
   243  	assert.Len(t, nodeAvailableResources, 1)
   244  	assert.Equal(t, int64(4), nodeAvailableResources[0].GetDiscreteResourceSpec().Value)
   245  
   246  	nodeRes[0].GetDiscreteResourceSpec().Value = 4
   247  
   248  	sanitize(nodeRes, &nodeAvailableResources)
   249  	assert.Len(t, nodeAvailableResources, 1)
   250  	assert.Equal(t, int64(4), nodeAvailableResources[0].GetDiscreteResourceSpec().Value)
   251  
   252  	nodeRes[0].GetDiscreteResourceSpec().Value = 2
   253  
   254  	sanitize(nodeRes, &nodeAvailableResources)
   255  	assert.Len(t, nodeAvailableResources, 1)
   256  	assert.Equal(t, int64(2), nodeAvailableResources[0].GetDiscreteResourceSpec().Value)
   257  
   258  	nodeRes = append(nodeRes, NewDiscrete("banana", 6))
   259  	nodeRes = append(nodeRes, NewDiscrete("cake", 6))
   260  	nodeAvailableResources = append(nodeAvailableResources, NewDiscrete("cake", 2))
   261  	nodeAvailableResources = append(nodeAvailableResources, NewDiscrete("apple", 4))
   262  	nodeAvailableResources = append(nodeAvailableResources, NewDiscrete("banana", 8))
   263  
   264  	sanitize(nodeRes, &nodeAvailableResources)
   265  	assert.Len(t, nodeAvailableResources, 3)
   266  	assert.Equal(t, int64(2), nodeAvailableResources[0].GetDiscreteResourceSpec().Value) // oranges
   267  	assert.Equal(t, int64(2), nodeAvailableResources[1].GetDiscreteResourceSpec().Value) // cake
   268  	assert.Equal(t, int64(6), nodeAvailableResources[2].GetDiscreteResourceSpec().Value) // banana
   269  }
   270  
   271  func TestSanitizeStr(t *testing.T) {
   272  	var nodeRes []*api.GenericResource
   273  	nodeAvailableResources := NewSet("apple", "red", "orange", "blue")
   274  
   275  	sanitize(nodeRes, &nodeAvailableResources)
   276  	assert.Len(t, nodeAvailableResources, 0)
   277  
   278  	nodeAvailableResources = NewSet("apple", "red", "orange", "blue")
   279  	nodeRes = NewSet("apple", "red", "orange", "blue", "green")
   280  	sanitize(nodeRes, &nodeAvailableResources)
   281  	assert.Len(t, nodeAvailableResources, 3)
   282  
   283  	nodeRes = NewSet("apple", "red", "orange", "blue")
   284  	sanitize(nodeRes, &nodeAvailableResources)
   285  	assert.Len(t, nodeAvailableResources, 3)
   286  
   287  	nodeRes = NewSet("apple", "red", "orange")
   288  	sanitize(nodeRes, &nodeAvailableResources)
   289  	assert.Len(t, nodeAvailableResources, 2)
   290  }
   291  
   292  func TestSanitizeChangeDiscreteToSet(t *testing.T) {
   293  	nodeRes := NewSet("apple", "red")
   294  	nodeAvailableResources := []*api.GenericResource{NewDiscrete("apple", 5)}
   295  
   296  	sanitize(nodeRes, &nodeAvailableResources)
   297  	assert.Len(t, nodeAvailableResources, 1)
   298  	assert.Equal(t, "red", nodeAvailableResources[0].GetNamedResourceSpec().Value)
   299  
   300  	nodeRes = NewSet("apple", "red", "orange", "green")
   301  	nodeAvailableResources = []*api.GenericResource{NewDiscrete("apple", 5)}
   302  
   303  	sanitize(nodeRes, &nodeAvailableResources)
   304  	assert.Len(t, nodeAvailableResources, 3)
   305  
   306  	for _, k := range []string{"red", "orange", "green"} {
   307  		assert.True(t, HasResource(NewString("apple", k), nodeAvailableResources))
   308  	}
   309  
   310  	nodeRes = append(nodeRes, NewSet("orange", "red", "orange", "green")...)
   311  	nodeRes = append(nodeRes, NewSet("cake", "red", "orange", "green")...)
   312  
   313  	nodeAvailableResources = NewSet("apple", "green")
   314  	nodeAvailableResources = append(nodeAvailableResources, NewDiscrete("cake", 3))
   315  	nodeAvailableResources = append(nodeAvailableResources, NewSet("orange", "orange", "blue")...)
   316  
   317  	sanitize(nodeRes, &nodeAvailableResources)
   318  	assert.Len(t, nodeAvailableResources, 5)
   319  
   320  	apples := GetResource("apple", nodeAvailableResources)
   321  	oranges := GetResource("orange", nodeAvailableResources)
   322  	cakes := GetResource("cake", nodeAvailableResources)
   323  	assert.Len(t, apples, 1)
   324  	assert.Len(t, oranges, 1)
   325  	assert.Len(t, cakes, 3)
   326  
   327  	for _, k := range []string{"green"} {
   328  		assert.True(t, HasResource(NewString("apple", k), apples))
   329  	}
   330  
   331  	for _, k := range []string{"orange"} {
   332  		assert.True(t, HasResource(NewString("orange", k), oranges))
   333  	}
   334  
   335  	for _, k := range []string{"red", "orange", "green"} {
   336  		assert.True(t, HasResource(NewString("cake", k), cakes))
   337  	}
   338  }
   339  
   340  func TestSanitizeChangeSetToDiscrete(t *testing.T) {
   341  	nodeRes := []*api.GenericResource{NewDiscrete("apple", 5)}
   342  	nodeAvailableResources := NewSet("apple", "red")
   343  
   344  	sanitize(nodeRes, &nodeAvailableResources)
   345  	assert.Len(t, nodeAvailableResources, 1)
   346  	assert.Equal(t, int64(5), nodeAvailableResources[0].GetDiscreteResourceSpec().Value)
   347  
   348  	nodeRes = []*api.GenericResource{NewDiscrete("apple", 5)}
   349  	nodeAvailableResources = NewSet("apple", "red", "orange", "green")
   350  
   351  	sanitize(nodeRes, &nodeAvailableResources)
   352  	assert.Len(t, nodeAvailableResources, 1)
   353  	assert.Equal(t, int64(5), nodeAvailableResources[0].GetDiscreteResourceSpec().Value)
   354  
   355  	nodeRes = append(nodeRes, NewDiscrete("orange", 3))
   356  	nodeRes = append(nodeRes, NewDiscrete("cake", 1))
   357  
   358  	nodeAvailableResources = append(nodeAvailableResources, NewDiscrete("cake", 2))
   359  	nodeAvailableResources = append(nodeAvailableResources, NewSet("orange", "orange", "blue")...)
   360  
   361  	sanitize(nodeRes, &nodeAvailableResources)
   362  	assert.Len(t, nodeAvailableResources, 3)
   363  
   364  	apples := GetResource("apple", nodeAvailableResources)
   365  	oranges := GetResource("orange", nodeAvailableResources)
   366  	cakes := GetResource("cake", nodeAvailableResources)
   367  	assert.Len(t, apples, 1)
   368  	assert.Len(t, oranges, 1)
   369  	assert.Len(t, cakes, 1)
   370  
   371  	assert.Equal(t, int64(5), apples[0].GetDiscreteResourceSpec().Value)
   372  	assert.Equal(t, int64(3), oranges[0].GetDiscreteResourceSpec().Value)
   373  	assert.Equal(t, int64(1), cakes[0].GetDiscreteResourceSpec().Value)
   374  }