github.com/quite/nomad@v0.8.6/client/alloc_endpoint_test.go (about) 1 package client 2 3 import ( 4 "fmt" 5 "testing" 6 7 "github.com/hashicorp/nomad/acl" 8 "github.com/hashicorp/nomad/client/config" 9 cstructs "github.com/hashicorp/nomad/client/structs" 10 "github.com/hashicorp/nomad/nomad/mock" 11 nstructs "github.com/hashicorp/nomad/nomad/structs" 12 "github.com/hashicorp/nomad/testutil" 13 "github.com/stretchr/testify/require" 14 ) 15 16 func TestAllocations_GarbageCollectAll(t *testing.T) { 17 t.Parallel() 18 require := require.New(t) 19 client := TestClient(t, nil) 20 21 req := &nstructs.NodeSpecificRequest{} 22 var resp nstructs.GenericResponse 23 require.Nil(client.ClientRPC("Allocations.GarbageCollectAll", &req, &resp)) 24 } 25 26 func TestAllocations_GarbageCollectAll_ACL(t *testing.T) { 27 t.Parallel() 28 require := require.New(t) 29 server, addr, root := testACLServer(t, nil) 30 defer server.Shutdown() 31 32 client := TestClient(t, func(c *config.Config) { 33 c.Servers = []string{addr} 34 c.ACLEnabled = true 35 }) 36 defer client.Shutdown() 37 38 // Try request without a token and expect failure 39 { 40 req := &nstructs.NodeSpecificRequest{} 41 var resp nstructs.GenericResponse 42 err := client.ClientRPC("Allocations.GarbageCollectAll", &req, &resp) 43 require.NotNil(err) 44 require.EqualError(err, nstructs.ErrPermissionDenied.Error()) 45 } 46 47 // Try request with an invalid token and expect failure 48 { 49 token := mock.CreatePolicyAndToken(t, server.State(), 1005, "invalid", mock.NodePolicy(acl.PolicyDeny)) 50 req := &nstructs.NodeSpecificRequest{} 51 req.AuthToken = token.SecretID 52 53 var resp nstructs.GenericResponse 54 err := client.ClientRPC("Allocations.GarbageCollectAll", &req, &resp) 55 56 require.NotNil(err) 57 require.EqualError(err, nstructs.ErrPermissionDenied.Error()) 58 } 59 60 // Try request with a valid token 61 { 62 token := mock.CreatePolicyAndToken(t, server.State(), 1007, "valid", mock.NodePolicy(acl.PolicyWrite)) 63 req := &nstructs.NodeSpecificRequest{} 64 req.AuthToken = token.SecretID 65 var resp nstructs.GenericResponse 66 require.Nil(client.ClientRPC("Allocations.GarbageCollectAll", &req, &resp)) 67 } 68 69 // Try request with a management token 70 { 71 req := &nstructs.NodeSpecificRequest{} 72 req.AuthToken = root.SecretID 73 var resp nstructs.GenericResponse 74 require.Nil(client.ClientRPC("Allocations.GarbageCollectAll", &req, &resp)) 75 } 76 } 77 78 func TestAllocations_GarbageCollect(t *testing.T) { 79 t.Parallel() 80 require := require.New(t) 81 client := TestClient(t, func(c *config.Config) { 82 c.GCDiskUsageThreshold = 100.0 83 }) 84 85 a := mock.Alloc() 86 a.Job.TaskGroups[0].Tasks[0].Driver = "mock_driver" 87 a.Job.TaskGroups[0].RestartPolicy = &nstructs.RestartPolicy{ 88 Attempts: 0, 89 Mode: nstructs.RestartPolicyModeFail, 90 } 91 a.Job.TaskGroups[0].Tasks[0].Config = map[string]interface{}{ 92 "run_for": "10ms", 93 } 94 require.Nil(client.addAlloc(a, "")) 95 96 // Try with bad alloc 97 req := &nstructs.AllocSpecificRequest{} 98 var resp nstructs.GenericResponse 99 err := client.ClientRPC("Allocations.GarbageCollect", &req, &resp) 100 require.NotNil(err) 101 102 // Try with good alloc 103 req.AllocID = a.ID 104 testutil.WaitForResult(func() (bool, error) { 105 // Check if has been removed first 106 if ar, ok := client.allocs[a.ID]; !ok || ar.IsDestroyed() { 107 return true, nil 108 } 109 110 var resp2 nstructs.GenericResponse 111 err := client.ClientRPC("Allocations.GarbageCollect", &req, &resp2) 112 return err == nil, err 113 }, func(err error) { 114 t.Fatalf("err: %v", err) 115 }) 116 } 117 118 func TestAllocations_GarbageCollect_ACL(t *testing.T) { 119 t.Parallel() 120 require := require.New(t) 121 server, addr, root := testACLServer(t, nil) 122 defer server.Shutdown() 123 124 client := TestClient(t, func(c *config.Config) { 125 c.Servers = []string{addr} 126 c.ACLEnabled = true 127 }) 128 defer client.Shutdown() 129 130 // Try request without a token and expect failure 131 { 132 req := &nstructs.AllocSpecificRequest{} 133 var resp nstructs.GenericResponse 134 err := client.ClientRPC("Allocations.GarbageCollect", &req, &resp) 135 require.NotNil(err) 136 require.EqualError(err, nstructs.ErrPermissionDenied.Error()) 137 } 138 139 // Try request with an invalid token and expect failure 140 { 141 token := mock.CreatePolicyAndToken(t, server.State(), 1005, "invalid", mock.NodePolicy(acl.PolicyDeny)) 142 req := &nstructs.AllocSpecificRequest{} 143 req.AuthToken = token.SecretID 144 145 var resp nstructs.GenericResponse 146 err := client.ClientRPC("Allocations.GarbageCollect", &req, &resp) 147 148 require.NotNil(err) 149 require.EqualError(err, nstructs.ErrPermissionDenied.Error()) 150 } 151 152 // Try request with a valid token 153 { 154 token := mock.CreatePolicyAndToken(t, server.State(), 1005, "test-valid", 155 mock.NamespacePolicy(nstructs.DefaultNamespace, "", []string{acl.NamespaceCapabilitySubmitJob})) 156 req := &nstructs.AllocSpecificRequest{} 157 req.AuthToken = token.SecretID 158 req.Namespace = nstructs.DefaultNamespace 159 160 var resp nstructs.GenericResponse 161 err := client.ClientRPC("Allocations.GarbageCollect", &req, &resp) 162 require.True(nstructs.IsErrUnknownAllocation(err)) 163 } 164 165 // Try request with a management token 166 { 167 req := &nstructs.AllocSpecificRequest{} 168 req.AuthToken = root.SecretID 169 170 var resp nstructs.GenericResponse 171 err := client.ClientRPC("Allocations.GarbageCollect", &req, &resp) 172 require.True(nstructs.IsErrUnknownAllocation(err)) 173 } 174 } 175 176 func TestAllocations_Stats(t *testing.T) { 177 t.Parallel() 178 require := require.New(t) 179 client := TestClient(t, nil) 180 181 a := mock.Alloc() 182 require.Nil(client.addAlloc(a, "")) 183 184 // Try with bad alloc 185 req := &cstructs.AllocStatsRequest{} 186 var resp cstructs.AllocStatsResponse 187 err := client.ClientRPC("Allocations.Stats", &req, &resp) 188 require.NotNil(err) 189 190 // Try with good alloc 191 req.AllocID = a.ID 192 testutil.WaitForResult(func() (bool, error) { 193 var resp2 cstructs.AllocStatsResponse 194 err := client.ClientRPC("Allocations.Stats", &req, &resp2) 195 if err != nil { 196 return false, err 197 } 198 if resp2.Stats == nil { 199 return false, fmt.Errorf("invalid stats object") 200 } 201 202 return true, nil 203 }, func(err error) { 204 t.Fatalf("err: %v", err) 205 }) 206 } 207 208 func TestAllocations_Stats_ACL(t *testing.T) { 209 t.Parallel() 210 require := require.New(t) 211 server, addr, root := testACLServer(t, nil) 212 defer server.Shutdown() 213 214 client := TestClient(t, func(c *config.Config) { 215 c.Servers = []string{addr} 216 c.ACLEnabled = true 217 }) 218 defer client.Shutdown() 219 220 // Try request without a token and expect failure 221 { 222 req := &cstructs.AllocStatsRequest{} 223 var resp cstructs.AllocStatsResponse 224 err := client.ClientRPC("Allocations.Stats", &req, &resp) 225 require.NotNil(err) 226 require.EqualError(err, nstructs.ErrPermissionDenied.Error()) 227 } 228 229 // Try request with an invalid token and expect failure 230 { 231 token := mock.CreatePolicyAndToken(t, server.State(), 1005, "invalid", mock.NodePolicy(acl.PolicyDeny)) 232 req := &cstructs.AllocStatsRequest{} 233 req.AuthToken = token.SecretID 234 235 var resp cstructs.AllocStatsResponse 236 err := client.ClientRPC("Allocations.Stats", &req, &resp) 237 238 require.NotNil(err) 239 require.EqualError(err, nstructs.ErrPermissionDenied.Error()) 240 } 241 242 // Try request with a valid token 243 { 244 token := mock.CreatePolicyAndToken(t, server.State(), 1005, "test-valid", 245 mock.NamespacePolicy(nstructs.DefaultNamespace, "", []string{acl.NamespaceCapabilityReadJob})) 246 req := &cstructs.AllocStatsRequest{} 247 req.AuthToken = token.SecretID 248 req.Namespace = nstructs.DefaultNamespace 249 250 var resp cstructs.AllocStatsResponse 251 err := client.ClientRPC("Allocations.Stats", &req, &resp) 252 require.True(nstructs.IsErrUnknownAllocation(err)) 253 } 254 255 // Try request with a management token 256 { 257 req := &cstructs.AllocStatsRequest{} 258 req.AuthToken = root.SecretID 259 260 var resp cstructs.AllocStatsResponse 261 err := client.ClientRPC("Allocations.Stats", &req, &resp) 262 require.True(nstructs.IsErrUnknownAllocation(err)) 263 } 264 }