github.com/kardianos/nomad@v0.1.3-0.20151022182107-b13df73ee850/nomad/state/state_store_test.go (about) 1 package state 2 3 import ( 4 "os" 5 "reflect" 6 "sort" 7 "testing" 8 9 "github.com/hashicorp/nomad/nomad/mock" 10 "github.com/hashicorp/nomad/nomad/structs" 11 ) 12 13 func testStateStore(t *testing.T) *StateStore { 14 state, err := NewStateStore(os.Stderr) 15 if err != nil { 16 t.Fatalf("err: %v", err) 17 } 18 if state == nil { 19 t.Fatalf("missing state") 20 } 21 return state 22 } 23 24 func TestStateStore_UpsertNode_Node(t *testing.T) { 25 state := testStateStore(t) 26 node := mock.Node() 27 28 err := state.UpsertNode(1000, node) 29 if err != nil { 30 t.Fatalf("err: %v", err) 31 } 32 33 out, err := state.NodeByID(node.ID) 34 if err != nil { 35 t.Fatalf("err: %v", err) 36 } 37 38 if !reflect.DeepEqual(node, out) { 39 t.Fatalf("bad: %#v %#v", node, out) 40 } 41 42 index, err := state.Index("nodes") 43 if err != nil { 44 t.Fatalf("err: %v", err) 45 } 46 if index != 1000 { 47 t.Fatalf("bad: %d", index) 48 } 49 } 50 51 func TestStateStore_DeleteNode_Node(t *testing.T) { 52 state := testStateStore(t) 53 node := mock.Node() 54 55 err := state.UpsertNode(1000, node) 56 if err != nil { 57 t.Fatalf("err: %v", err) 58 } 59 60 err = state.DeleteNode(1001, node.ID) 61 if err != nil { 62 t.Fatalf("err: %v", err) 63 } 64 65 out, err := state.NodeByID(node.ID) 66 if err != nil { 67 t.Fatalf("err: %v", err) 68 } 69 70 if out != nil { 71 t.Fatalf("bad: %#v %#v", node, out) 72 } 73 74 index, err := state.Index("nodes") 75 if err != nil { 76 t.Fatalf("err: %v", err) 77 } 78 if index != 1001 { 79 t.Fatalf("bad: %d", index) 80 } 81 } 82 83 func TestStateStore_UpdateNodeStatus_Node(t *testing.T) { 84 state := testStateStore(t) 85 node := mock.Node() 86 87 err := state.UpsertNode(1000, node) 88 if err != nil { 89 t.Fatalf("err: %v", err) 90 } 91 92 err = state.UpdateNodeStatus(1001, node.ID, structs.NodeStatusReady) 93 if err != nil { 94 t.Fatalf("err: %v", err) 95 } 96 97 out, err := state.NodeByID(node.ID) 98 if err != nil { 99 t.Fatalf("err: %v", err) 100 } 101 102 if out.Status != structs.NodeStatusReady { 103 t.Fatalf("bad: %#v", out) 104 } 105 if out.ModifyIndex != 1001 { 106 t.Fatalf("bad: %#v", out) 107 } 108 109 index, err := state.Index("nodes") 110 if err != nil { 111 t.Fatalf("err: %v", err) 112 } 113 if index != 1001 { 114 t.Fatalf("bad: %d", index) 115 } 116 } 117 118 func TestStateStore_UpdateNodeDrain_Node(t *testing.T) { 119 state := testStateStore(t) 120 node := mock.Node() 121 122 err := state.UpsertNode(1000, node) 123 if err != nil { 124 t.Fatalf("err: %v", err) 125 } 126 127 err = state.UpdateNodeDrain(1001, node.ID, true) 128 if err != nil { 129 t.Fatalf("err: %v", err) 130 } 131 132 out, err := state.NodeByID(node.ID) 133 if err != nil { 134 t.Fatalf("err: %v", err) 135 } 136 137 if !out.Drain { 138 t.Fatalf("bad: %#v", out) 139 } 140 if out.ModifyIndex != 1001 { 141 t.Fatalf("bad: %#v", out) 142 } 143 144 index, err := state.Index("nodes") 145 if err != nil { 146 t.Fatalf("err: %v", err) 147 } 148 if index != 1001 { 149 t.Fatalf("bad: %d", index) 150 } 151 } 152 153 func TestStateStore_Nodes(t *testing.T) { 154 state := testStateStore(t) 155 var nodes []*structs.Node 156 157 for i := 0; i < 10; i++ { 158 node := mock.Node() 159 nodes = append(nodes, node) 160 161 err := state.UpsertNode(1000+uint64(i), node) 162 if err != nil { 163 t.Fatalf("err: %v", err) 164 } 165 } 166 167 iter, err := state.Nodes() 168 if err != nil { 169 t.Fatalf("err: %v", err) 170 } 171 172 var out []*structs.Node 173 for { 174 raw := iter.Next() 175 if raw == nil { 176 break 177 } 178 out = append(out, raw.(*structs.Node)) 179 } 180 181 sort.Sort(NodeIDSort(nodes)) 182 sort.Sort(NodeIDSort(out)) 183 184 if !reflect.DeepEqual(nodes, out) { 185 t.Fatalf("bad: %#v %#v", nodes, out) 186 } 187 } 188 189 func TestStateStore_RestoreNode(t *testing.T) { 190 state := testStateStore(t) 191 192 restore, err := state.Restore() 193 if err != nil { 194 t.Fatalf("err: %v", err) 195 } 196 197 node := mock.Node() 198 err = restore.NodeRestore(node) 199 if err != nil { 200 t.Fatalf("err: %v", err) 201 } 202 203 restore.Commit() 204 205 out, err := state.NodeByID(node.ID) 206 if err != nil { 207 t.Fatalf("err: %v", err) 208 } 209 210 if !reflect.DeepEqual(out, node) { 211 t.Fatalf("Bad: %#v %#v", out, node) 212 } 213 } 214 215 func TestStateStore_UpsertJob_Job(t *testing.T) { 216 state := testStateStore(t) 217 job := mock.Job() 218 219 err := state.UpsertJob(1000, job) 220 if err != nil { 221 t.Fatalf("err: %v", err) 222 } 223 224 out, err := state.JobByID(job.ID) 225 if err != nil { 226 t.Fatalf("err: %v", err) 227 } 228 229 if !reflect.DeepEqual(job, out) { 230 t.Fatalf("bad: %#v %#v", job, out) 231 } 232 233 index, err := state.Index("jobs") 234 if err != nil { 235 t.Fatalf("err: %v", err) 236 } 237 if index != 1000 { 238 t.Fatalf("bad: %d", index) 239 } 240 } 241 242 func TestStateStore_UpdateUpsertJob_Job(t *testing.T) { 243 state := testStateStore(t) 244 job := mock.Job() 245 246 err := state.UpsertJob(1000, job) 247 if err != nil { 248 t.Fatalf("err: %v", err) 249 } 250 251 job2 := mock.Job() 252 job2.ID = job.ID 253 err = state.UpsertJob(1001, job2) 254 if err != nil { 255 t.Fatalf("err: %v", err) 256 } 257 258 out, err := state.JobByID(job.ID) 259 if err != nil { 260 t.Fatalf("err: %v", err) 261 } 262 263 if !reflect.DeepEqual(job2, out) { 264 t.Fatalf("bad: %#v %#v", job2, out) 265 } 266 267 if out.CreateIndex != 1000 { 268 t.Fatalf("bad: %#v", out) 269 } 270 if out.ModifyIndex != 1001 { 271 t.Fatalf("bad: %#v", out) 272 } 273 274 index, err := state.Index("jobs") 275 if err != nil { 276 t.Fatalf("err: %v", err) 277 } 278 if index != 1001 { 279 t.Fatalf("bad: %d", index) 280 } 281 } 282 283 func TestStateStore_DeleteJob_Job(t *testing.T) { 284 state := testStateStore(t) 285 job := mock.Job() 286 287 err := state.UpsertJob(1000, job) 288 if err != nil { 289 t.Fatalf("err: %v", err) 290 } 291 292 err = state.DeleteJob(1001, job.ID) 293 if err != nil { 294 t.Fatalf("err: %v", err) 295 } 296 297 out, err := state.JobByID(job.ID) 298 if err != nil { 299 t.Fatalf("err: %v", err) 300 } 301 302 if out != nil { 303 t.Fatalf("bad: %#v %#v", job, out) 304 } 305 306 index, err := state.Index("jobs") 307 if err != nil { 308 t.Fatalf("err: %v", err) 309 } 310 if index != 1001 { 311 t.Fatalf("bad: %d", index) 312 } 313 } 314 315 func TestStateStore_Jobs(t *testing.T) { 316 state := testStateStore(t) 317 var jobs []*structs.Job 318 319 for i := 0; i < 10; i++ { 320 job := mock.Job() 321 jobs = append(jobs, job) 322 323 err := state.UpsertJob(1000+uint64(i), job) 324 if err != nil { 325 t.Fatalf("err: %v", err) 326 } 327 } 328 329 iter, err := state.Jobs() 330 if err != nil { 331 t.Fatalf("err: %v", err) 332 } 333 334 var out []*structs.Job 335 for { 336 raw := iter.Next() 337 if raw == nil { 338 break 339 } 340 out = append(out, raw.(*structs.Job)) 341 } 342 343 sort.Sort(JobIDSort(jobs)) 344 sort.Sort(JobIDSort(out)) 345 346 if !reflect.DeepEqual(jobs, out) { 347 t.Fatalf("bad: %#v %#v", jobs, out) 348 } 349 } 350 351 func TestStateStore_JobsByScheduler(t *testing.T) { 352 state := testStateStore(t) 353 var serviceJobs []*structs.Job 354 var sysJobs []*structs.Job 355 356 for i := 0; i < 10; i++ { 357 job := mock.Job() 358 serviceJobs = append(serviceJobs, job) 359 360 err := state.UpsertJob(1000+uint64(i), job) 361 if err != nil { 362 t.Fatalf("err: %v", err) 363 } 364 } 365 366 for i := 0; i < 10; i++ { 367 job := mock.SystemJob() 368 sysJobs = append(sysJobs, job) 369 370 err := state.UpsertJob(2000+uint64(i), job) 371 if err != nil { 372 t.Fatalf("err: %v", err) 373 } 374 } 375 376 iter, err := state.JobsByScheduler("service") 377 if err != nil { 378 t.Fatalf("err: %v", err) 379 } 380 381 var outService []*structs.Job 382 for { 383 raw := iter.Next() 384 if raw == nil { 385 break 386 } 387 outService = append(outService, raw.(*structs.Job)) 388 } 389 390 iter, err = state.JobsByScheduler("system") 391 if err != nil { 392 t.Fatalf("err: %v", err) 393 } 394 395 var outSystem []*structs.Job 396 for { 397 raw := iter.Next() 398 if raw == nil { 399 break 400 } 401 outSystem = append(outSystem, raw.(*structs.Job)) 402 } 403 404 sort.Sort(JobIDSort(serviceJobs)) 405 sort.Sort(JobIDSort(sysJobs)) 406 sort.Sort(JobIDSort(outService)) 407 sort.Sort(JobIDSort(outSystem)) 408 409 if !reflect.DeepEqual(serviceJobs, outService) { 410 t.Fatalf("bad: %#v %#v", serviceJobs, outService) 411 } 412 413 if !reflect.DeepEqual(sysJobs, outSystem) { 414 t.Fatalf("bad: %#v %#v", sysJobs, outSystem) 415 } 416 } 417 418 func TestStateStore_RestoreJob(t *testing.T) { 419 state := testStateStore(t) 420 421 restore, err := state.Restore() 422 if err != nil { 423 t.Fatalf("err: %v", err) 424 } 425 426 job := mock.Job() 427 err = restore.JobRestore(job) 428 if err != nil { 429 t.Fatalf("err: %v", err) 430 } 431 432 restore.Commit() 433 434 out, err := state.JobByID(job.ID) 435 if err != nil { 436 t.Fatalf("err: %v", err) 437 } 438 439 if !reflect.DeepEqual(out, job) { 440 t.Fatalf("Bad: %#v %#v", out, job) 441 } 442 } 443 444 func TestStateStore_Indexes(t *testing.T) { 445 state := testStateStore(t) 446 node := mock.Node() 447 448 err := state.UpsertNode(1000, node) 449 if err != nil { 450 t.Fatalf("err: %v", err) 451 } 452 453 iter, err := state.Indexes() 454 if err != nil { 455 t.Fatalf("err: %v", err) 456 } 457 458 var out []*IndexEntry 459 for { 460 raw := iter.Next() 461 if raw == nil { 462 break 463 } 464 out = append(out, raw.(*IndexEntry)) 465 } 466 467 expect := []*IndexEntry{ 468 &IndexEntry{"nodes", 1000}, 469 } 470 471 if !reflect.DeepEqual(expect, out) { 472 t.Fatalf("bad: %#v %#v", expect, out) 473 } 474 } 475 476 func TestStateStore_RestoreIndex(t *testing.T) { 477 state := testStateStore(t) 478 479 restore, err := state.Restore() 480 if err != nil { 481 t.Fatalf("err: %v", err) 482 } 483 484 index := &IndexEntry{"jobs", 1000} 485 err = restore.IndexRestore(index) 486 if err != nil { 487 t.Fatalf("err: %v", err) 488 } 489 490 restore.Commit() 491 492 out, err := state.Index("jobs") 493 if err != nil { 494 t.Fatalf("err: %v", err) 495 } 496 497 if out != 1000 { 498 t.Fatalf("Bad: %#v %#v", out, 1000) 499 } 500 } 501 502 func TestStateStore_UpsertEvals_Eval(t *testing.T) { 503 state := testStateStore(t) 504 eval := mock.Eval() 505 506 err := state.UpsertEvals(1000, []*structs.Evaluation{eval}) 507 if err != nil { 508 t.Fatalf("err: %v", err) 509 } 510 511 out, err := state.EvalByID(eval.ID) 512 if err != nil { 513 t.Fatalf("err: %v", err) 514 } 515 516 if !reflect.DeepEqual(eval, out) { 517 t.Fatalf("bad: %#v %#v", eval, out) 518 } 519 520 index, err := state.Index("evals") 521 if err != nil { 522 t.Fatalf("err: %v", err) 523 } 524 if index != 1000 { 525 t.Fatalf("bad: %d", index) 526 } 527 } 528 529 func TestStateStore_Update_UpsertEvals_Eval(t *testing.T) { 530 state := testStateStore(t) 531 eval := mock.Eval() 532 533 err := state.UpsertEvals(1000, []*structs.Evaluation{eval}) 534 if err != nil { 535 t.Fatalf("err: %v", err) 536 } 537 538 eval2 := mock.Eval() 539 eval2.ID = eval.ID 540 err = state.UpsertEvals(1001, []*structs.Evaluation{eval2}) 541 if err != nil { 542 t.Fatalf("err: %v", err) 543 } 544 545 out, err := state.EvalByID(eval.ID) 546 if err != nil { 547 t.Fatalf("err: %v", err) 548 } 549 550 if !reflect.DeepEqual(eval2, out) { 551 t.Fatalf("bad: %#v %#v", eval2, out) 552 } 553 554 if out.CreateIndex != 1000 { 555 t.Fatalf("bad: %#v", out) 556 } 557 if out.ModifyIndex != 1001 { 558 t.Fatalf("bad: %#v", out) 559 } 560 561 index, err := state.Index("evals") 562 if err != nil { 563 t.Fatalf("err: %v", err) 564 } 565 if index != 1001 { 566 t.Fatalf("bad: %d", index) 567 } 568 } 569 570 func TestStateStore_DeleteEval_Eval(t *testing.T) { 571 state := testStateStore(t) 572 eval := mock.Eval() 573 eval2 := mock.Eval() 574 alloc := mock.Alloc() 575 alloc2 := mock.Alloc() 576 577 err := state.UpsertEvals(1000, []*structs.Evaluation{eval, eval2}) 578 if err != nil { 579 t.Fatalf("err: %v", err) 580 } 581 582 err = state.UpsertAllocs(1001, []*structs.Allocation{alloc, alloc2}) 583 if err != nil { 584 t.Fatalf("err: %v", err) 585 } 586 587 notify1 := make(chan struct{}, 1) 588 state.WatchAllocs(alloc.NodeID, notify1) 589 590 err = state.DeleteEval(1002, []string{eval.ID, eval2.ID}, []string{alloc.ID, alloc2.ID}) 591 if err != nil { 592 t.Fatalf("err: %v", err) 593 } 594 595 out, err := state.EvalByID(eval.ID) 596 if err != nil { 597 t.Fatalf("err: %v", err) 598 } 599 600 if out != nil { 601 t.Fatalf("bad: %#v %#v", eval, out) 602 } 603 604 out, err = state.EvalByID(eval2.ID) 605 if err != nil { 606 t.Fatalf("err: %v", err) 607 } 608 609 if out != nil { 610 t.Fatalf("bad: %#v %#v", eval, out) 611 } 612 613 outA, err := state.AllocByID(alloc.ID) 614 if err != nil { 615 t.Fatalf("err: %v", err) 616 } 617 618 if out != nil { 619 t.Fatalf("bad: %#v %#v", alloc, outA) 620 } 621 622 outA, err = state.AllocByID(alloc2.ID) 623 if err != nil { 624 t.Fatalf("err: %v", err) 625 } 626 627 if out != nil { 628 t.Fatalf("bad: %#v %#v", alloc, outA) 629 } 630 631 index, err := state.Index("evals") 632 if err != nil { 633 t.Fatalf("err: %v", err) 634 } 635 if index != 1002 { 636 t.Fatalf("bad: %d", index) 637 } 638 639 index, err = state.Index("allocs") 640 if err != nil { 641 t.Fatalf("err: %v", err) 642 } 643 if index != 1002 { 644 t.Fatalf("bad: %d", index) 645 } 646 647 select { 648 case <-notify1: 649 default: 650 t.Fatalf("should be notified") 651 } 652 } 653 654 func TestStateStore_EvalsByJob(t *testing.T) { 655 state := testStateStore(t) 656 657 eval1 := mock.Eval() 658 eval2 := mock.Eval() 659 eval2.JobID = eval1.JobID 660 eval3 := mock.Eval() 661 evals := []*structs.Evaluation{eval1, eval2} 662 663 err := state.UpsertEvals(1000, evals) 664 if err != nil { 665 t.Fatalf("err: %v", err) 666 } 667 err = state.UpsertEvals(1001, []*structs.Evaluation{eval3}) 668 if err != nil { 669 t.Fatalf("err: %v", err) 670 } 671 672 out, err := state.EvalsByJob(eval1.JobID) 673 if err != nil { 674 t.Fatalf("err: %v", err) 675 } 676 677 sort.Sort(EvalIDSort(evals)) 678 sort.Sort(EvalIDSort(out)) 679 680 if !reflect.DeepEqual(evals, out) { 681 t.Fatalf("bad: %#v %#v", evals, out) 682 } 683 } 684 685 func TestStateStore_Evals(t *testing.T) { 686 state := testStateStore(t) 687 var evals []*structs.Evaluation 688 689 for i := 0; i < 10; i++ { 690 eval := mock.Eval() 691 evals = append(evals, eval) 692 693 err := state.UpsertEvals(1000+uint64(i), []*structs.Evaluation{eval}) 694 if err != nil { 695 t.Fatalf("err: %v", err) 696 } 697 } 698 699 iter, err := state.Evals() 700 if err != nil { 701 t.Fatalf("err: %v", err) 702 } 703 704 var out []*structs.Evaluation 705 for { 706 raw := iter.Next() 707 if raw == nil { 708 break 709 } 710 out = append(out, raw.(*structs.Evaluation)) 711 } 712 713 sort.Sort(EvalIDSort(evals)) 714 sort.Sort(EvalIDSort(out)) 715 716 if !reflect.DeepEqual(evals, out) { 717 t.Fatalf("bad: %#v %#v", evals, out) 718 } 719 } 720 721 func TestStateStore_RestoreEval(t *testing.T) { 722 state := testStateStore(t) 723 724 restore, err := state.Restore() 725 if err != nil { 726 t.Fatalf("err: %v", err) 727 } 728 729 job := mock.Eval() 730 err = restore.EvalRestore(job) 731 if err != nil { 732 t.Fatalf("err: %v", err) 733 } 734 735 restore.Commit() 736 737 out, err := state.EvalByID(job.ID) 738 if err != nil { 739 t.Fatalf("err: %v", err) 740 } 741 742 if !reflect.DeepEqual(out, job) { 743 t.Fatalf("Bad: %#v %#v", out, job) 744 } 745 } 746 747 func TestStateStore_UpdateAllocFromClient(t *testing.T) { 748 state := testStateStore(t) 749 750 alloc := mock.Alloc() 751 err := state.UpsertAllocs(1000, []*structs.Allocation{alloc}) 752 if err != nil { 753 t.Fatalf("err: %v", err) 754 } 755 756 update := new(structs.Allocation) 757 *update = *alloc 758 update.ClientStatus = structs.AllocClientStatusFailed 759 760 err = state.UpdateAllocFromClient(1001, update) 761 if err != nil { 762 t.Fatalf("err: %v", err) 763 } 764 765 out, err := state.AllocByID(alloc.ID) 766 if err != nil { 767 t.Fatalf("err: %v", err) 768 } 769 770 update.ModifyIndex = 1001 771 if !reflect.DeepEqual(update, out) { 772 t.Fatalf("bad: %#v %#v", update, out) 773 } 774 775 index, err := state.Index("allocs") 776 if err != nil { 777 t.Fatalf("err: %v", err) 778 } 779 if index != 1001 { 780 t.Fatalf("bad: %d", index) 781 } 782 } 783 784 func TestStateStore_UpsertAlloc_Alloc(t *testing.T) { 785 state := testStateStore(t) 786 787 alloc := mock.Alloc() 788 err := state.UpsertAllocs(1000, []*structs.Allocation{alloc}) 789 if err != nil { 790 t.Fatalf("err: %v", err) 791 } 792 793 out, err := state.AllocByID(alloc.ID) 794 if err != nil { 795 t.Fatalf("err: %v", err) 796 } 797 798 if !reflect.DeepEqual(alloc, out) { 799 t.Fatalf("bad: %#v %#v", alloc, out) 800 } 801 802 index, err := state.Index("allocs") 803 if err != nil { 804 t.Fatalf("err: %v", err) 805 } 806 if index != 1000 { 807 t.Fatalf("bad: %d", index) 808 } 809 } 810 811 func TestStateStore_WatchAllocs(t *testing.T) { 812 state := testStateStore(t) 813 814 notify1 := make(chan struct{}, 1) 815 notify2 := make(chan struct{}, 1) 816 state.WatchAllocs("foo", notify1) 817 state.WatchAllocs("foo", notify2) 818 state.StopWatchAllocs("foo", notify2) 819 820 alloc := mock.Alloc() 821 alloc.NodeID = "foo" 822 err := state.UpsertAllocs(1000, []*structs.Allocation{alloc}) 823 if err != nil { 824 t.Fatalf("err: %v", err) 825 } 826 827 select { 828 case <-notify1: 829 default: 830 t.Fatalf("should be notified") 831 } 832 833 select { 834 case <-notify2: 835 t.Fatalf("should not be notified") 836 default: 837 } 838 } 839 840 func TestStateStore_UpdateAlloc_Alloc(t *testing.T) { 841 state := testStateStore(t) 842 alloc := mock.Alloc() 843 844 err := state.UpsertAllocs(1000, []*structs.Allocation{alloc}) 845 if err != nil { 846 t.Fatalf("err: %v", err) 847 } 848 849 alloc2 := mock.Alloc() 850 alloc2.ID = alloc.ID 851 alloc2.NodeID = alloc.NodeID + ".new" 852 err = state.UpsertAllocs(1001, []*structs.Allocation{alloc2}) 853 if err != nil { 854 t.Fatalf("err: %v", err) 855 } 856 857 out, err := state.AllocByID(alloc.ID) 858 if err != nil { 859 t.Fatalf("err: %v", err) 860 } 861 862 if !reflect.DeepEqual(alloc2, out) { 863 t.Fatalf("bad: %#v %#v", alloc2, out) 864 } 865 866 if out.CreateIndex != 1000 { 867 t.Fatalf("bad: %#v", out) 868 } 869 if out.ModifyIndex != 1001 { 870 t.Fatalf("bad: %#v", out) 871 } 872 873 index, err := state.Index("allocs") 874 if err != nil { 875 t.Fatalf("err: %v", err) 876 } 877 if index != 1001 { 878 t.Fatalf("bad: %d", index) 879 } 880 } 881 882 func TestStateStore_EvictAlloc_Alloc(t *testing.T) { 883 state := testStateStore(t) 884 alloc := mock.Alloc() 885 886 err := state.UpsertAllocs(1000, []*structs.Allocation{alloc}) 887 if err != nil { 888 t.Fatalf("err: %v", err) 889 } 890 891 alloc2 := new(structs.Allocation) 892 *alloc2 = *alloc 893 alloc2.DesiredStatus = structs.AllocDesiredStatusEvict 894 err = state.UpsertAllocs(1001, []*structs.Allocation{alloc2}) 895 if err != nil { 896 t.Fatalf("err: %v", err) 897 } 898 899 out, err := state.AllocByID(alloc.ID) 900 if err != nil { 901 t.Fatalf("err: %v", err) 902 } 903 904 if out.DesiredStatus != structs.AllocDesiredStatusEvict { 905 t.Fatalf("bad: %#v %#v", alloc, out) 906 } 907 908 index, err := state.Index("allocs") 909 if err != nil { 910 t.Fatalf("err: %v", err) 911 } 912 if index != 1001 { 913 t.Fatalf("bad: %d", index) 914 } 915 } 916 917 func TestStateStore_AllocsByNode(t *testing.T) { 918 state := testStateStore(t) 919 var allocs []*structs.Allocation 920 921 for i := 0; i < 10; i++ { 922 alloc := mock.Alloc() 923 alloc.NodeID = "foo" 924 allocs = append(allocs, alloc) 925 } 926 927 err := state.UpsertAllocs(1000, allocs) 928 if err != nil { 929 t.Fatalf("err: %v", err) 930 } 931 932 out, err := state.AllocsByNode("foo") 933 if err != nil { 934 t.Fatalf("err: %v", err) 935 } 936 937 sort.Sort(AllocIDSort(allocs)) 938 sort.Sort(AllocIDSort(out)) 939 940 if !reflect.DeepEqual(allocs, out) { 941 t.Fatalf("bad: %#v %#v", allocs, out) 942 } 943 } 944 945 func TestStateStore_AllocsByJob(t *testing.T) { 946 state := testStateStore(t) 947 var allocs []*structs.Allocation 948 949 for i := 0; i < 10; i++ { 950 alloc := mock.Alloc() 951 alloc.JobID = "foo" 952 allocs = append(allocs, alloc) 953 } 954 955 err := state.UpsertAllocs(1000, allocs) 956 if err != nil { 957 t.Fatalf("err: %v", err) 958 } 959 960 out, err := state.AllocsByJob("foo") 961 if err != nil { 962 t.Fatalf("err: %v", err) 963 } 964 965 sort.Sort(AllocIDSort(allocs)) 966 sort.Sort(AllocIDSort(out)) 967 968 if !reflect.DeepEqual(allocs, out) { 969 t.Fatalf("bad: %#v %#v", allocs, out) 970 } 971 } 972 973 func TestStateStore_Allocs(t *testing.T) { 974 state := testStateStore(t) 975 var allocs []*structs.Allocation 976 977 for i := 0; i < 10; i++ { 978 alloc := mock.Alloc() 979 allocs = append(allocs, alloc) 980 } 981 982 err := state.UpsertAllocs(1000, allocs) 983 if err != nil { 984 t.Fatalf("err: %v", err) 985 } 986 987 iter, err := state.Allocs() 988 if err != nil { 989 t.Fatalf("err: %v", err) 990 } 991 992 var out []*structs.Allocation 993 for { 994 raw := iter.Next() 995 if raw == nil { 996 break 997 } 998 out = append(out, raw.(*structs.Allocation)) 999 } 1000 1001 sort.Sort(AllocIDSort(allocs)) 1002 sort.Sort(AllocIDSort(out)) 1003 1004 if !reflect.DeepEqual(allocs, out) { 1005 t.Fatalf("bad: %#v %#v", allocs, out) 1006 } 1007 } 1008 1009 func TestStateStore_RestoreAlloc(t *testing.T) { 1010 state := testStateStore(t) 1011 1012 restore, err := state.Restore() 1013 if err != nil { 1014 t.Fatalf("err: %v", err) 1015 } 1016 1017 alloc := mock.Alloc() 1018 err = restore.AllocRestore(alloc) 1019 if err != nil { 1020 t.Fatalf("err: %v", err) 1021 } 1022 1023 restore.Commit() 1024 1025 out, err := state.AllocByID(alloc.ID) 1026 if err != nil { 1027 t.Fatalf("err: %v", err) 1028 } 1029 1030 if !reflect.DeepEqual(out, alloc) { 1031 t.Fatalf("Bad: %#v %#v", out, alloc) 1032 } 1033 } 1034 1035 // NodeIDSort is used to sort nodes by ID 1036 type NodeIDSort []*structs.Node 1037 1038 func (n NodeIDSort) Len() int { 1039 return len(n) 1040 } 1041 1042 func (n NodeIDSort) Less(i, j int) bool { 1043 return n[i].ID < n[j].ID 1044 } 1045 1046 func (n NodeIDSort) Swap(i, j int) { 1047 n[i], n[j] = n[j], n[i] 1048 } 1049 1050 // JobIDis used to sort jobs by id 1051 type JobIDSort []*structs.Job 1052 1053 func (n JobIDSort) Len() int { 1054 return len(n) 1055 } 1056 1057 func (n JobIDSort) Less(i, j int) bool { 1058 return n[i].ID < n[j].ID 1059 } 1060 1061 func (n JobIDSort) Swap(i, j int) { 1062 n[i], n[j] = n[j], n[i] 1063 } 1064 1065 // EvalIDis used to sort evals by id 1066 type EvalIDSort []*structs.Evaluation 1067 1068 func (n EvalIDSort) Len() int { 1069 return len(n) 1070 } 1071 1072 func (n EvalIDSort) Less(i, j int) bool { 1073 return n[i].ID < n[j].ID 1074 } 1075 1076 func (n EvalIDSort) Swap(i, j int) { 1077 n[i], n[j] = n[j], n[i] 1078 } 1079 1080 // AllocIDsort used to sort allocations by id 1081 type AllocIDSort []*structs.Allocation 1082 1083 func (n AllocIDSort) Len() int { 1084 return len(n) 1085 } 1086 1087 func (n AllocIDSort) Less(i, j int) bool { 1088 return n[i].ID < n[j].ID 1089 } 1090 1091 func (n AllocIDSort) Swap(i, j int) { 1092 n[i], n[j] = n[j], n[i] 1093 }