go.temporal.io/server@v1.23.0/common/persistence/tests/execution_mutable_state.go (about) 1 // The MIT License 2 // 3 // Copyright (c) 2020 Temporal Technologies Inc. All rights reserved. 4 // 5 // Copyright (c) 2020 Uber Technologies, Inc. 6 // 7 // Permission is hereby granted, free of charge, to any person obtaining a copy 8 // of this software and associated documentation files (the "Software"), to deal 9 // in the Software without restriction, including without limitation the rights 10 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 // copies of the Software, and to permit persons to whom the Software is 12 // furnished to do so, subject to the following conditions: 13 // 14 // The above copyright notice and this permission notice shall be included in 15 // all copies or substantial portions of the Software. 16 // 17 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 23 // THE SOFTWARE. 24 25 package tests 26 27 import ( 28 "context" 29 "math/rand" 30 "testing" 31 "time" 32 33 "github.com/google/uuid" 34 "github.com/stretchr/testify/require" 35 "github.com/stretchr/testify/suite" 36 enumspb "go.temporal.io/api/enums/v1" 37 historypb "go.temporal.io/api/history/v1" 38 "go.temporal.io/api/serviceerror" 39 "google.golang.org/protobuf/proto" 40 41 enumsspb "go.temporal.io/server/api/enums/v1" 42 persistencespb "go.temporal.io/server/api/persistence/v1" 43 "go.temporal.io/server/common/convert" 44 "go.temporal.io/server/common/debug" 45 "go.temporal.io/server/common/dynamicconfig" 46 "go.temporal.io/server/common/log" 47 p "go.temporal.io/server/common/persistence" 48 "go.temporal.io/server/common/persistence/serialization" 49 "go.temporal.io/server/common/testing/protorequire" 50 ) 51 52 type ( 53 ExecutionMutableStateSuite struct { 54 suite.Suite 55 *require.Assertions 56 protorequire.ProtoAssertions 57 58 ShardID int32 59 RangeID int64 60 NamespaceID string 61 WorkflowID string 62 RunID string 63 64 ShardManager p.ShardManager 65 ExecutionManager p.ExecutionManager 66 Logger log.Logger 67 68 Ctx context.Context 69 Cancel context.CancelFunc 70 } 71 ) 72 73 func NewExecutionMutableStateSuite( 74 t *testing.T, 75 shardStore p.ShardStore, 76 executionStore p.ExecutionStore, 77 serializer serialization.Serializer, 78 logger log.Logger, 79 ) *ExecutionMutableStateSuite { 80 return &ExecutionMutableStateSuite{ 81 Assertions: require.New(t), 82 ProtoAssertions: protorequire.New(t), 83 ShardManager: p.NewShardManager( 84 shardStore, 85 serializer, 86 ), 87 ExecutionManager: p.NewExecutionManager( 88 executionStore, 89 serializer, 90 nil, 91 logger, 92 dynamicconfig.GetIntPropertyFn(4*1024*1024), 93 ), 94 Logger: logger, 95 } 96 } 97 98 func (s *ExecutionMutableStateSuite) SetupSuite() { 99 } 100 101 func (s *ExecutionMutableStateSuite) TearDownSuite() { 102 } 103 104 func (s *ExecutionMutableStateSuite) SetupTest() { 105 s.Assertions = require.New(s.T()) 106 s.Ctx, s.Cancel = context.WithTimeout(context.Background(), 30*time.Second*debug.TimeoutMultiplier) 107 108 s.ShardID++ 109 resp, err := s.ShardManager.GetOrCreateShard(s.Ctx, &p.GetOrCreateShardRequest{ 110 ShardID: s.ShardID, 111 InitialShardInfo: &persistencespb.ShardInfo{ 112 ShardId: s.ShardID, 113 RangeId: 1, 114 }, 115 }) 116 s.NoError(err) 117 previousRangeID := resp.ShardInfo.RangeId 118 resp.ShardInfo.RangeId++ 119 err = s.ShardManager.UpdateShard(s.Ctx, &p.UpdateShardRequest{ 120 ShardInfo: resp.ShardInfo, 121 PreviousRangeID: previousRangeID, 122 }) 123 s.NoError(err) 124 s.RangeID = resp.ShardInfo.RangeId 125 126 s.NamespaceID = uuid.New().String() 127 s.WorkflowID = uuid.New().String() 128 s.RunID = uuid.New().String() 129 } 130 131 func (s *ExecutionMutableStateSuite) TearDownTest() { 132 s.Cancel() 133 } 134 135 func (s *ExecutionMutableStateSuite) TestCreate_BrandNew() { 136 newSnapshot := s.CreateWorkflow( 137 rand.Int63(), 138 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 139 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 140 rand.Int63(), 141 ) 142 143 s.AssertEqualWithDB(newSnapshot) 144 } 145 146 func (s *ExecutionMutableStateSuite) TestCreate_BrandNew_CurrentConflict() { 147 lastWriteVersion := rand.Int63() 148 newSnapshot := s.CreateWorkflow( 149 lastWriteVersion, 150 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 151 enumspb.WORKFLOW_EXECUTION_STATUS_COMPLETED, 152 rand.Int63(), 153 ) 154 155 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 156 ShardID: s.ShardID, 157 RangeID: s.RangeID, 158 Mode: p.CreateWorkflowModeBrandNew, 159 160 PreviousRunID: "", 161 PreviousLastWriteVersion: 0, 162 163 NewWorkflowSnapshot: *newSnapshot, 164 NewWorkflowEvents: nil, 165 }) 166 if err, ok := err.(*p.CurrentWorkflowConditionFailedError); ok { 167 err.Msg = "" 168 } 169 s.Equal(&p.CurrentWorkflowConditionFailedError{ 170 Msg: "", 171 RequestID: newSnapshot.ExecutionState.CreateRequestId, 172 RunID: newSnapshot.ExecutionState.RunId, 173 State: newSnapshot.ExecutionState.State, 174 Status: newSnapshot.ExecutionState.Status, 175 LastWriteVersion: lastWriteVersion, 176 }, err) 177 178 s.AssertEqualWithDB(newSnapshot) 179 } 180 181 func (s *ExecutionMutableStateSuite) TestCreate_Reuse() { 182 prevLastWriteVersion := rand.Int63() 183 prevSnapshot := s.CreateWorkflow( 184 prevLastWriteVersion, 185 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 186 enumspb.WORKFLOW_EXECUTION_STATUS_COMPLETED, 187 rand.Int63(), 188 ) 189 190 newSnapshot := RandomSnapshot( 191 s.NamespaceID, 192 s.WorkflowID, 193 uuid.New().String(), 194 rand.Int63(), 195 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 196 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 197 rand.Int63(), 198 ) 199 200 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 201 ShardID: s.ShardID, 202 RangeID: s.RangeID, 203 Mode: p.CreateWorkflowModeUpdateCurrent, 204 205 PreviousRunID: prevSnapshot.ExecutionState.RunId, 206 PreviousLastWriteVersion: prevLastWriteVersion, 207 208 NewWorkflowSnapshot: *newSnapshot, 209 NewWorkflowEvents: nil, 210 }) 211 s.NoError(err) 212 213 s.AssertEqualWithDB(newSnapshot) 214 } 215 216 func (s *ExecutionMutableStateSuite) TestCreate_Reuse_CurrentConflict() { 217 prevLastWriteVersion := rand.Int63() 218 prevSnapshot := s.CreateWorkflow( 219 prevLastWriteVersion, 220 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 221 enumspb.WORKFLOW_EXECUTION_STATUS_COMPLETED, 222 rand.Int63(), 223 ) 224 225 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 226 ShardID: s.ShardID, 227 RangeID: s.RangeID, 228 Mode: p.CreateWorkflowModeUpdateCurrent, 229 230 PreviousRunID: uuid.New().String(), 231 PreviousLastWriteVersion: rand.Int63(), 232 233 NewWorkflowSnapshot: *prevSnapshot, 234 NewWorkflowEvents: nil, 235 }) 236 if err, ok := err.(*p.CurrentWorkflowConditionFailedError); ok { 237 err.Msg = "" 238 } 239 s.Equal(&p.CurrentWorkflowConditionFailedError{ 240 Msg: "", 241 RequestID: prevSnapshot.ExecutionState.CreateRequestId, 242 RunID: prevSnapshot.ExecutionState.RunId, 243 State: prevSnapshot.ExecutionState.State, 244 Status: prevSnapshot.ExecutionState.Status, 245 LastWriteVersion: prevLastWriteVersion, 246 }, err) 247 248 s.AssertEqualWithDB(prevSnapshot) 249 } 250 251 func (s *ExecutionMutableStateSuite) TestCreate_Zombie() { 252 prevLastWriteVersion := rand.Int63() 253 _ = s.CreateWorkflow( 254 prevLastWriteVersion, 255 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 256 enumspb.WORKFLOW_EXECUTION_STATUS_COMPLETED, 257 rand.Int63(), 258 ) 259 260 newSnapshot := RandomSnapshot( 261 s.NamespaceID, 262 s.WorkflowID, 263 uuid.New().String(), 264 rand.Int63(), 265 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 266 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 267 rand.Int63(), 268 ) 269 270 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 271 ShardID: s.ShardID, 272 RangeID: s.RangeID, 273 Mode: p.CreateWorkflowModeBypassCurrent, 274 275 PreviousRunID: "", 276 PreviousLastWriteVersion: 0, 277 278 NewWorkflowSnapshot: *newSnapshot, 279 NewWorkflowEvents: nil, 280 }) 281 s.NoError(err) 282 283 s.AssertEqualWithDB(newSnapshot) 284 } 285 286 func (s *ExecutionMutableStateSuite) TestCreate_Conflict() { 287 lastWriteVersion := rand.Int63() 288 newSnapshot := s.CreateWorkflow( 289 lastWriteVersion, 290 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 291 enumspb.WORKFLOW_EXECUTION_STATUS_COMPLETED, 292 rand.Int63(), 293 ) 294 295 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 296 ShardID: s.ShardID, 297 RangeID: s.RangeID, 298 Mode: p.CreateWorkflowModeUpdateCurrent, 299 300 PreviousRunID: newSnapshot.ExecutionState.RunId, 301 PreviousLastWriteVersion: lastWriteVersion, 302 303 NewWorkflowSnapshot: *newSnapshot, 304 NewWorkflowEvents: nil, 305 }) 306 s.IsType(&p.WorkflowConditionFailedError{}, err) 307 } 308 309 func (s *ExecutionMutableStateSuite) TestCreate_ClosedWorkflow_BrandNew() { 310 newSnapshot := s.CreateWorkflow( 311 rand.Int63(), 312 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 313 enumspb.WORKFLOW_EXECUTION_STATUS_TERMINATED, 314 rand.Int63(), 315 ) 316 317 s.AssertEqualWithDB(newSnapshot) 318 } 319 320 func (s *ExecutionMutableStateSuite) TestCreate_ClosedWorkflow_Bypass() { 321 prevLastWriteVersion := rand.Int63() 322 _ = s.CreateWorkflow( 323 prevLastWriteVersion, 324 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 325 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 326 rand.Int63(), 327 ) 328 329 newSnapshot := RandomSnapshot( 330 s.NamespaceID, 331 s.WorkflowID, 332 uuid.New().String(), 333 rand.Int63(), 334 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 335 enumspb.WORKFLOW_EXECUTION_STATUS_TERMINATED, 336 rand.Int63(), 337 ) 338 339 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 340 ShardID: s.ShardID, 341 RangeID: s.RangeID, 342 Mode: p.CreateWorkflowModeBypassCurrent, 343 344 PreviousRunID: "", 345 PreviousLastWriteVersion: 0, 346 347 NewWorkflowSnapshot: *newSnapshot, 348 NewWorkflowEvents: nil, 349 }) 350 s.NoError(err) 351 352 s.AssertEqualWithDB(newSnapshot) 353 } 354 355 func (s *ExecutionMutableStateSuite) TestCreate_ClosedWorkflow_UpdateCurrent() { 356 prevLastWriteVersion := rand.Int63() 357 prevSnapshot := s.CreateWorkflow( 358 prevLastWriteVersion, 359 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 360 enumspb.WORKFLOW_EXECUTION_STATUS_COMPLETED, 361 rand.Int63(), 362 ) 363 364 newSnapshot := RandomSnapshot( 365 s.NamespaceID, 366 s.WorkflowID, 367 uuid.New().String(), 368 rand.Int63(), 369 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 370 enumspb.WORKFLOW_EXECUTION_STATUS_COMPLETED, 371 rand.Int63(), 372 ) 373 374 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 375 ShardID: s.ShardID, 376 RangeID: s.RangeID, 377 Mode: p.CreateWorkflowModeUpdateCurrent, 378 379 PreviousRunID: prevSnapshot.ExecutionState.RunId, 380 PreviousLastWriteVersion: prevLastWriteVersion, 381 382 NewWorkflowSnapshot: *newSnapshot, 383 NewWorkflowEvents: nil, 384 }) 385 s.NoError(err) 386 387 s.AssertEqualWithDB(newSnapshot) 388 } 389 390 func (s *ExecutionMutableStateSuite) TestUpdate_NotZombie() { 391 currentSnapshot := s.CreateWorkflow( 392 rand.Int63(), 393 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 394 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 395 rand.Int63(), 396 ) 397 398 currentMutation := RandomMutation( 399 s.NamespaceID, 400 s.WorkflowID, 401 s.RunID, 402 rand.Int63(), 403 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 404 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 405 currentSnapshot.DBRecordVersion+1, 406 ) 407 _, err := s.ExecutionManager.UpdateWorkflowExecution(s.Ctx, &p.UpdateWorkflowExecutionRequest{ 408 ShardID: s.ShardID, 409 RangeID: s.RangeID, 410 Mode: p.UpdateWorkflowModeUpdateCurrent, 411 412 UpdateWorkflowMutation: *currentMutation, 413 UpdateWorkflowEvents: nil, 414 415 NewWorkflowSnapshot: nil, 416 NewWorkflowEvents: nil, 417 }) 418 s.NoError(err) 419 420 s.AssertEqualWithDB(currentSnapshot, currentMutation) 421 } 422 423 func (s *ExecutionMutableStateSuite) TestUpdate_NotZombie_CurrentConflict() { 424 _ = s.CreateWorkflow( 425 rand.Int63(), 426 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 427 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 428 rand.Int63(), 429 ) 430 431 currentMutation := RandomMutation( 432 s.NamespaceID, 433 s.WorkflowID, 434 uuid.New().String(), 435 rand.Int63(), 436 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 437 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 438 rand.Int63(), 439 ) 440 _, err := s.ExecutionManager.UpdateWorkflowExecution(s.Ctx, &p.UpdateWorkflowExecutionRequest{ 441 ShardID: s.ShardID, 442 RangeID: s.RangeID, 443 Mode: p.UpdateWorkflowModeUpdateCurrent, 444 445 UpdateWorkflowMutation: *currentMutation, 446 UpdateWorkflowEvents: nil, 447 448 NewWorkflowSnapshot: nil, 449 NewWorkflowEvents: nil, 450 }) 451 s.IsType(&p.CurrentWorkflowConditionFailedError{}, err) 452 453 s.AssertMissingFromDB( 454 currentMutation.ExecutionInfo.NamespaceId, 455 currentMutation.ExecutionInfo.WorkflowId, 456 currentMutation.ExecutionState.RunId, 457 ) 458 } 459 460 func (s *ExecutionMutableStateSuite) TestUpdate_NotZombie_Conflict() { 461 currentSnapshot := s.CreateWorkflow( 462 rand.Int63(), 463 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 464 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 465 rand.Int63(), 466 ) 467 468 currentMutation := RandomMutation( 469 s.NamespaceID, 470 s.WorkflowID, 471 s.RunID, 472 rand.Int63(), 473 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 474 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 475 rand.Int63(), 476 ) 477 _, err := s.ExecutionManager.UpdateWorkflowExecution(s.Ctx, &p.UpdateWorkflowExecutionRequest{ 478 ShardID: s.ShardID, 479 RangeID: s.RangeID, 480 Mode: p.UpdateWorkflowModeUpdateCurrent, 481 482 UpdateWorkflowMutation: *currentMutation, 483 UpdateWorkflowEvents: nil, 484 485 NewWorkflowSnapshot: nil, 486 NewWorkflowEvents: nil, 487 }) 488 s.IsType(&p.WorkflowConditionFailedError{}, err) 489 490 s.AssertEqualWithDB(currentSnapshot) 491 } 492 493 func (s *ExecutionMutableStateSuite) TestUpdate_NotZombie_WithNew() { 494 currentSnapshot := s.CreateWorkflow( 495 rand.Int63(), 496 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 497 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 498 rand.Int63(), 499 ) 500 501 currentMutation := RandomMutation( 502 s.NamespaceID, 503 s.WorkflowID, 504 s.RunID, 505 rand.Int63(), 506 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 507 enumspb.WORKFLOW_EXECUTION_STATUS_COMPLETED, 508 currentSnapshot.DBRecordVersion+1, 509 ) 510 newSnapshot := RandomSnapshot( 511 s.NamespaceID, 512 s.WorkflowID, 513 uuid.New().String(), 514 rand.Int63(), 515 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 516 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 517 rand.Int63(), 518 ) 519 _, err := s.ExecutionManager.UpdateWorkflowExecution(s.Ctx, &p.UpdateWorkflowExecutionRequest{ 520 ShardID: s.ShardID, 521 RangeID: s.RangeID, 522 Mode: p.UpdateWorkflowModeUpdateCurrent, 523 524 UpdateWorkflowMutation: *currentMutation, 525 UpdateWorkflowEvents: nil, 526 527 NewWorkflowSnapshot: newSnapshot, 528 NewWorkflowEvents: nil, 529 }) 530 s.NoError(err) 531 532 s.AssertEqualWithDB(currentSnapshot, currentMutation) 533 s.AssertEqualWithDB(newSnapshot) 534 } 535 536 func (s *ExecutionMutableStateSuite) TestUpdate_Zombie() { 537 _ = s.CreateWorkflow( 538 rand.Int63(), 539 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 540 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 541 rand.Int63(), 542 ) 543 runID := uuid.New().String() 544 zombieSnapshot := RandomSnapshot( 545 s.NamespaceID, 546 s.WorkflowID, 547 runID, 548 rand.Int63(), 549 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 550 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 551 rand.Int63(), 552 ) 553 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 554 ShardID: s.ShardID, 555 RangeID: s.RangeID, 556 Mode: p.CreateWorkflowModeBypassCurrent, 557 558 PreviousRunID: "", 559 PreviousLastWriteVersion: 0, 560 561 NewWorkflowSnapshot: *zombieSnapshot, 562 NewWorkflowEvents: nil, 563 }) 564 s.NoError(err) 565 566 zombieMutation := RandomMutation( 567 s.NamespaceID, 568 s.WorkflowID, 569 runID, 570 rand.Int63(), 571 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 572 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 573 zombieSnapshot.DBRecordVersion+1, 574 ) 575 _, err = s.ExecutionManager.UpdateWorkflowExecution(s.Ctx, &p.UpdateWorkflowExecutionRequest{ 576 ShardID: s.ShardID, 577 RangeID: s.RangeID, 578 Mode: p.UpdateWorkflowModeBypassCurrent, 579 580 UpdateWorkflowMutation: *zombieMutation, 581 UpdateWorkflowEvents: nil, 582 583 NewWorkflowSnapshot: nil, 584 NewWorkflowEvents: nil, 585 }) 586 s.NoError(err) 587 588 s.AssertEqualWithDB(zombieSnapshot, zombieMutation) 589 } 590 591 func (s *ExecutionMutableStateSuite) TestUpdate_Zombie_CurrentConflict() { 592 currentSnapshot := s.CreateWorkflow( 593 rand.Int63(), 594 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 595 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 596 rand.Int63(), 597 ) 598 599 currentMutation := RandomMutation( 600 s.NamespaceID, 601 s.WorkflowID, 602 s.RunID, 603 rand.Int63(), 604 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 605 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 606 currentSnapshot.DBRecordVersion+1, 607 ) 608 _, err := s.ExecutionManager.UpdateWorkflowExecution(s.Ctx, &p.UpdateWorkflowExecutionRequest{ 609 ShardID: s.ShardID, 610 RangeID: s.RangeID, 611 Mode: p.UpdateWorkflowModeBypassCurrent, 612 613 UpdateWorkflowMutation: *currentMutation, 614 UpdateWorkflowEvents: nil, 615 616 NewWorkflowSnapshot: nil, 617 NewWorkflowEvents: nil, 618 }) 619 s.IsType(&p.CurrentWorkflowConditionFailedError{}, err) 620 621 s.AssertEqualWithDB(currentSnapshot) 622 } 623 624 func (s *ExecutionMutableStateSuite) TestUpdate_Zombie_Conflict() { 625 _ = s.CreateWorkflow( 626 rand.Int63(), 627 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 628 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 629 rand.Int63(), 630 ) 631 runID := uuid.New().String() 632 zombieSnapshot := RandomSnapshot( 633 s.NamespaceID, 634 s.WorkflowID, 635 runID, 636 rand.Int63(), 637 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 638 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 639 rand.Int63(), 640 ) 641 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 642 ShardID: s.ShardID, 643 RangeID: s.RangeID, 644 Mode: p.CreateWorkflowModeBypassCurrent, 645 646 PreviousRunID: "", 647 PreviousLastWriteVersion: 0, 648 649 NewWorkflowSnapshot: *zombieSnapshot, 650 NewWorkflowEvents: nil, 651 }) 652 s.NoError(err) 653 654 zombieMutation := RandomMutation( 655 s.NamespaceID, 656 s.WorkflowID, 657 runID, 658 rand.Int63(), 659 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 660 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 661 rand.Int63(), 662 ) 663 _, err = s.ExecutionManager.UpdateWorkflowExecution(s.Ctx, &p.UpdateWorkflowExecutionRequest{ 664 ShardID: s.ShardID, 665 RangeID: s.RangeID, 666 Mode: p.UpdateWorkflowModeBypassCurrent, 667 668 UpdateWorkflowMutation: *zombieMutation, 669 UpdateWorkflowEvents: nil, 670 671 NewWorkflowSnapshot: nil, 672 NewWorkflowEvents: nil, 673 }) 674 s.IsType(&p.WorkflowConditionFailedError{}, err) 675 676 s.AssertEqualWithDB(zombieSnapshot) 677 } 678 679 func (s *ExecutionMutableStateSuite) TestUpdate_Zombie_WithNew() { 680 _ = s.CreateWorkflow( 681 rand.Int63(), 682 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 683 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 684 rand.Int63(), 685 ) 686 runID := uuid.New().String() 687 zombieSnapshot := RandomSnapshot( 688 s.NamespaceID, 689 s.WorkflowID, 690 runID, 691 rand.Int63(), 692 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 693 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 694 rand.Int63(), 695 ) 696 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 697 ShardID: s.ShardID, 698 RangeID: s.RangeID, 699 Mode: p.CreateWorkflowModeBypassCurrent, 700 701 PreviousRunID: "", 702 PreviousLastWriteVersion: 0, 703 704 NewWorkflowSnapshot: *zombieSnapshot, 705 NewWorkflowEvents: nil, 706 }) 707 s.NoError(err) 708 709 zombieMutation := RandomMutation( 710 s.NamespaceID, 711 s.WorkflowID, 712 runID, 713 rand.Int63(), 714 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 715 enumspb.WORKFLOW_EXECUTION_STATUS_COMPLETED, 716 zombieSnapshot.DBRecordVersion+1, 717 ) 718 newZombieSnapshot := RandomSnapshot( 719 s.NamespaceID, 720 s.WorkflowID, 721 uuid.New().String(), 722 rand.Int63(), 723 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 724 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 725 rand.Int63(), 726 ) 727 _, err = s.ExecutionManager.UpdateWorkflowExecution(s.Ctx, &p.UpdateWorkflowExecutionRequest{ 728 ShardID: s.ShardID, 729 RangeID: s.RangeID, 730 Mode: p.UpdateWorkflowModeBypassCurrent, 731 732 UpdateWorkflowMutation: *zombieMutation, 733 UpdateWorkflowEvents: nil, 734 735 NewWorkflowSnapshot: newZombieSnapshot, 736 NewWorkflowEvents: nil, 737 }) 738 s.NoError(err) 739 740 s.AssertEqualWithDB(zombieSnapshot, zombieMutation) 741 s.AssertEqualWithDB(newZombieSnapshot) 742 } 743 744 func (s *ExecutionMutableStateSuite) TestConflictResolve_SuppressCurrent() { 745 currentSnapshot := s.CreateWorkflow( 746 rand.Int63(), 747 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 748 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 749 rand.Int63(), 750 ) 751 752 runID := uuid.New().String() 753 baseSnapshot := RandomSnapshot( 754 s.NamespaceID, 755 s.WorkflowID, 756 runID, 757 rand.Int63(), 758 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 759 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 760 rand.Int63(), 761 ) 762 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 763 ShardID: s.ShardID, 764 RangeID: s.RangeID, 765 Mode: p.CreateWorkflowModeBypassCurrent, 766 767 PreviousRunID: "", 768 PreviousLastWriteVersion: 0, 769 770 NewWorkflowSnapshot: *baseSnapshot, 771 NewWorkflowEvents: nil, 772 }) 773 s.NoError(err) 774 775 resetSnapshot := RandomSnapshot( 776 s.NamespaceID, 777 s.WorkflowID, 778 runID, 779 rand.Int63(), 780 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 781 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 782 baseSnapshot.DBRecordVersion+1, 783 ) 784 currentMutation := RandomMutation( 785 s.NamespaceID, 786 s.WorkflowID, 787 s.RunID, 788 rand.Int63(), 789 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 790 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 791 currentSnapshot.DBRecordVersion+1, 792 ) 793 _, err = s.ExecutionManager.ConflictResolveWorkflowExecution(s.Ctx, &p.ConflictResolveWorkflowExecutionRequest{ 794 ShardID: s.ShardID, 795 RangeID: s.RangeID, 796 Mode: p.ConflictResolveWorkflowModeUpdateCurrent, 797 798 ResetWorkflowSnapshot: *resetSnapshot, 799 ResetWorkflowEvents: nil, 800 801 NewWorkflowSnapshot: nil, 802 NewWorkflowEvents: nil, 803 804 CurrentWorkflowMutation: currentMutation, 805 CurrentWorkflowEvents: nil, 806 }) 807 s.NoError(err) 808 809 s.AssertEqualWithDB(resetSnapshot) 810 s.AssertEqualWithDB(currentSnapshot, currentMutation) 811 } 812 813 func (s *ExecutionMutableStateSuite) TestConflictResolve_SuppressCurrent_CurrentConflict() { 814 currentSnapshot := s.CreateWorkflow( 815 rand.Int63(), 816 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 817 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 818 rand.Int63(), 819 ) 820 821 runID := uuid.New().String() 822 baseSnapshot := RandomSnapshot( 823 s.NamespaceID, 824 s.WorkflowID, 825 runID, 826 rand.Int63(), 827 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 828 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 829 rand.Int63(), 830 ) 831 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 832 ShardID: s.ShardID, 833 RangeID: s.RangeID, 834 Mode: p.CreateWorkflowModeBypassCurrent, 835 836 PreviousRunID: "", 837 PreviousLastWriteVersion: 0, 838 839 NewWorkflowSnapshot: *baseSnapshot, 840 NewWorkflowEvents: nil, 841 }) 842 s.NoError(err) 843 844 resetSnapshot := RandomSnapshot( 845 s.NamespaceID, 846 s.WorkflowID, 847 runID, 848 rand.Int63(), 849 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 850 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 851 baseSnapshot.DBRecordVersion+1, 852 ) 853 currentMutation := RandomMutation( 854 s.NamespaceID, 855 s.WorkflowID, 856 uuid.New().String(), 857 rand.Int63(), 858 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 859 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 860 rand.Int63(), 861 ) 862 _, err = s.ExecutionManager.ConflictResolveWorkflowExecution(s.Ctx, &p.ConflictResolveWorkflowExecutionRequest{ 863 ShardID: s.ShardID, 864 RangeID: s.RangeID, 865 Mode: p.ConflictResolveWorkflowModeUpdateCurrent, 866 867 ResetWorkflowSnapshot: *resetSnapshot, 868 ResetWorkflowEvents: nil, 869 870 NewWorkflowSnapshot: nil, 871 NewWorkflowEvents: nil, 872 873 CurrentWorkflowMutation: currentMutation, 874 CurrentWorkflowEvents: nil, 875 }) 876 s.IsType(&p.CurrentWorkflowConditionFailedError{}, err) 877 878 s.AssertEqualWithDB(baseSnapshot) 879 s.AssertEqualWithDB(currentSnapshot) 880 } 881 882 func (s *ExecutionMutableStateSuite) TestConflictResolve_SuppressCurrent_Conflict_Case1() { 883 currentSnapshot := s.CreateWorkflow( 884 rand.Int63(), 885 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 886 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 887 rand.Int63(), 888 ) 889 890 runID := uuid.New().String() 891 baseSnapshot := RandomSnapshot( 892 s.NamespaceID, 893 s.WorkflowID, 894 runID, 895 rand.Int63(), 896 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 897 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 898 rand.Int63(), 899 ) 900 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 901 ShardID: s.ShardID, 902 RangeID: s.RangeID, 903 Mode: p.CreateWorkflowModeBypassCurrent, 904 905 PreviousRunID: "", 906 PreviousLastWriteVersion: 0, 907 908 NewWorkflowSnapshot: *baseSnapshot, 909 NewWorkflowEvents: nil, 910 }) 911 s.NoError(err) 912 913 resetSnapshot := RandomSnapshot( 914 s.NamespaceID, 915 s.WorkflowID, 916 runID, 917 rand.Int63(), 918 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 919 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 920 baseSnapshot.DBRecordVersion+1, 921 ) 922 currentMutation := RandomMutation( 923 s.NamespaceID, 924 s.WorkflowID, 925 s.RunID, 926 rand.Int63(), 927 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 928 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 929 rand.Int63(), 930 ) 931 _, err = s.ExecutionManager.ConflictResolveWorkflowExecution(s.Ctx, &p.ConflictResolveWorkflowExecutionRequest{ 932 ShardID: s.ShardID, 933 RangeID: s.RangeID, 934 Mode: p.ConflictResolveWorkflowModeUpdateCurrent, 935 936 ResetWorkflowSnapshot: *resetSnapshot, 937 ResetWorkflowEvents: nil, 938 939 NewWorkflowSnapshot: nil, 940 NewWorkflowEvents: nil, 941 942 CurrentWorkflowMutation: currentMutation, 943 CurrentWorkflowEvents: nil, 944 }) 945 s.IsType(&p.WorkflowConditionFailedError{}, err) 946 947 s.AssertEqualWithDB(baseSnapshot) 948 s.AssertEqualWithDB(currentSnapshot) 949 } 950 951 func (s *ExecutionMutableStateSuite) TestConflictResolve_SuppressCurrent_Conflict_Case2() { 952 currentSnapshot := s.CreateWorkflow( 953 rand.Int63(), 954 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 955 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 956 rand.Int63(), 957 ) 958 959 runID := uuid.New().String() 960 baseSnapshot := RandomSnapshot( 961 s.NamespaceID, 962 s.WorkflowID, 963 runID, 964 rand.Int63(), 965 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 966 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 967 rand.Int63(), 968 ) 969 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 970 ShardID: s.ShardID, 971 RangeID: s.RangeID, 972 Mode: p.CreateWorkflowModeBypassCurrent, 973 974 PreviousRunID: "", 975 PreviousLastWriteVersion: 0, 976 977 NewWorkflowSnapshot: *baseSnapshot, 978 NewWorkflowEvents: nil, 979 }) 980 s.NoError(err) 981 982 resetSnapshot := RandomSnapshot( 983 s.NamespaceID, 984 s.WorkflowID, 985 runID, 986 rand.Int63(), 987 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 988 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 989 rand.Int63(), 990 ) 991 currentMutation := RandomMutation( 992 s.NamespaceID, 993 s.WorkflowID, 994 s.RunID, 995 rand.Int63(), 996 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 997 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 998 currentSnapshot.DBRecordVersion+1, 999 ) 1000 _, err = s.ExecutionManager.ConflictResolveWorkflowExecution(s.Ctx, &p.ConflictResolveWorkflowExecutionRequest{ 1001 ShardID: s.ShardID, 1002 RangeID: s.RangeID, 1003 Mode: p.ConflictResolveWorkflowModeUpdateCurrent, 1004 1005 ResetWorkflowSnapshot: *resetSnapshot, 1006 ResetWorkflowEvents: nil, 1007 1008 NewWorkflowSnapshot: nil, 1009 NewWorkflowEvents: nil, 1010 1011 CurrentWorkflowMutation: currentMutation, 1012 CurrentWorkflowEvents: nil, 1013 }) 1014 s.IsType(&p.WorkflowConditionFailedError{}, err) 1015 1016 s.AssertEqualWithDB(baseSnapshot) 1017 s.AssertEqualWithDB(currentSnapshot) 1018 } 1019 1020 func (s *ExecutionMutableStateSuite) TestConflictResolve_SuppressCurrent_WithNew() { 1021 currentSnapshot := s.CreateWorkflow( 1022 rand.Int63(), 1023 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 1024 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1025 rand.Int63(), 1026 ) 1027 1028 runID := uuid.New().String() 1029 baseSnapshot := RandomSnapshot( 1030 s.NamespaceID, 1031 s.WorkflowID, 1032 runID, 1033 rand.Int63(), 1034 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 1035 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1036 rand.Int63(), 1037 ) 1038 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 1039 ShardID: s.ShardID, 1040 RangeID: s.RangeID, 1041 Mode: p.CreateWorkflowModeBypassCurrent, 1042 1043 PreviousRunID: "", 1044 PreviousLastWriteVersion: 0, 1045 1046 NewWorkflowSnapshot: *baseSnapshot, 1047 NewWorkflowEvents: nil, 1048 }) 1049 s.NoError(err) 1050 1051 resetSnapshot := RandomSnapshot( 1052 s.NamespaceID, 1053 s.WorkflowID, 1054 runID, 1055 rand.Int63(), 1056 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 1057 enumspb.WORKFLOW_EXECUTION_STATUS_COMPLETED, 1058 baseSnapshot.DBRecordVersion+1, 1059 ) 1060 newSnapshot := RandomSnapshot( 1061 s.NamespaceID, 1062 s.WorkflowID, 1063 uuid.New().String(), 1064 rand.Int63(), 1065 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 1066 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1067 rand.Int63(), 1068 ) 1069 currentMutation := RandomMutation( 1070 s.NamespaceID, 1071 s.WorkflowID, 1072 s.RunID, 1073 rand.Int63(), 1074 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 1075 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1076 currentSnapshot.DBRecordVersion+1, 1077 ) 1078 _, err = s.ExecutionManager.ConflictResolveWorkflowExecution(s.Ctx, &p.ConflictResolveWorkflowExecutionRequest{ 1079 ShardID: s.ShardID, 1080 RangeID: s.RangeID, 1081 Mode: p.ConflictResolveWorkflowModeUpdateCurrent, 1082 1083 ResetWorkflowSnapshot: *resetSnapshot, 1084 ResetWorkflowEvents: nil, 1085 1086 NewWorkflowSnapshot: newSnapshot, 1087 NewWorkflowEvents: nil, 1088 1089 CurrentWorkflowMutation: currentMutation, 1090 CurrentWorkflowEvents: nil, 1091 }) 1092 s.NoError(err) 1093 1094 s.AssertEqualWithDB(resetSnapshot) 1095 s.AssertEqualWithDB(newSnapshot) 1096 s.AssertEqualWithDB(currentSnapshot, currentMutation) 1097 } 1098 1099 func (s *ExecutionMutableStateSuite) TestConflictResolve_ResetCurrent() { 1100 baseSnapshot := s.CreateWorkflow( 1101 rand.Int63(), 1102 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 1103 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1104 rand.Int63(), 1105 ) 1106 1107 resetSnapshot := RandomSnapshot( 1108 s.NamespaceID, 1109 s.WorkflowID, 1110 s.RunID, 1111 rand.Int63(), 1112 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 1113 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1114 baseSnapshot.DBRecordVersion+1, 1115 ) 1116 _, err := s.ExecutionManager.ConflictResolveWorkflowExecution(s.Ctx, &p.ConflictResolveWorkflowExecutionRequest{ 1117 ShardID: s.ShardID, 1118 RangeID: s.RangeID, 1119 Mode: p.ConflictResolveWorkflowModeUpdateCurrent, 1120 1121 ResetWorkflowSnapshot: *resetSnapshot, 1122 ResetWorkflowEvents: nil, 1123 1124 NewWorkflowSnapshot: nil, 1125 NewWorkflowEvents: nil, 1126 1127 CurrentWorkflowMutation: nil, 1128 CurrentWorkflowEvents: nil, 1129 }) 1130 s.NoError(err) 1131 1132 s.AssertEqualWithDB(resetSnapshot) 1133 } 1134 1135 func (s *ExecutionMutableStateSuite) TestConflictResolve_ResetCurrent_CurrentConflict() { 1136 _ = s.CreateWorkflow( 1137 rand.Int63(), 1138 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 1139 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1140 rand.Int63(), 1141 ) 1142 runID := uuid.New().String() 1143 baseSnapshot := RandomSnapshot( 1144 s.NamespaceID, 1145 s.WorkflowID, 1146 runID, 1147 rand.Int63(), 1148 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 1149 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1150 rand.Int63(), 1151 ) 1152 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 1153 ShardID: s.ShardID, 1154 RangeID: s.RangeID, 1155 Mode: p.CreateWorkflowModeBypassCurrent, 1156 1157 PreviousRunID: "", 1158 PreviousLastWriteVersion: 0, 1159 1160 NewWorkflowSnapshot: *baseSnapshot, 1161 NewWorkflowEvents: nil, 1162 }) 1163 s.NoError(err) 1164 1165 resetSnapshot := RandomSnapshot( 1166 s.NamespaceID, 1167 s.WorkflowID, 1168 runID, 1169 rand.Int63(), 1170 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 1171 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1172 baseSnapshot.DBRecordVersion+1, 1173 ) 1174 _, err = s.ExecutionManager.ConflictResolveWorkflowExecution(s.Ctx, &p.ConflictResolveWorkflowExecutionRequest{ 1175 ShardID: s.ShardID, 1176 RangeID: s.RangeID, 1177 Mode: p.ConflictResolveWorkflowModeUpdateCurrent, 1178 1179 ResetWorkflowSnapshot: *resetSnapshot, 1180 ResetWorkflowEvents: nil, 1181 1182 NewWorkflowSnapshot: nil, 1183 NewWorkflowEvents: nil, 1184 1185 CurrentWorkflowMutation: nil, 1186 CurrentWorkflowEvents: nil, 1187 }) 1188 s.IsType(&p.CurrentWorkflowConditionFailedError{}, err) 1189 1190 s.AssertEqualWithDB(baseSnapshot) 1191 } 1192 1193 func (s *ExecutionMutableStateSuite) TestConflictResolve_ResetCurrent_Conflict() { 1194 baseSnapshot := s.CreateWorkflow( 1195 rand.Int63(), 1196 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 1197 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1198 rand.Int63(), 1199 ) 1200 1201 resetSnapshot := RandomSnapshot( 1202 s.NamespaceID, 1203 s.WorkflowID, 1204 s.RunID, 1205 rand.Int63(), 1206 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 1207 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1208 rand.Int63(), 1209 ) 1210 _, err := s.ExecutionManager.ConflictResolveWorkflowExecution(s.Ctx, &p.ConflictResolveWorkflowExecutionRequest{ 1211 ShardID: s.ShardID, 1212 RangeID: s.RangeID, 1213 Mode: p.ConflictResolveWorkflowModeUpdateCurrent, 1214 1215 ResetWorkflowSnapshot: *resetSnapshot, 1216 ResetWorkflowEvents: nil, 1217 1218 NewWorkflowSnapshot: nil, 1219 NewWorkflowEvents: nil, 1220 1221 CurrentWorkflowMutation: nil, 1222 CurrentWorkflowEvents: nil, 1223 }) 1224 s.IsType(&p.WorkflowConditionFailedError{}, err) 1225 1226 s.AssertEqualWithDB(baseSnapshot) 1227 } 1228 1229 func (s *ExecutionMutableStateSuite) TestConflictResolve_ResetCurrent_WithNew() { 1230 baseSnapshot := s.CreateWorkflow( 1231 rand.Int63(), 1232 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 1233 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1234 rand.Int63(), 1235 ) 1236 1237 resetSnapshot := RandomSnapshot( 1238 s.NamespaceID, 1239 s.WorkflowID, 1240 s.RunID, 1241 rand.Int63(), 1242 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 1243 enumspb.WORKFLOW_EXECUTION_STATUS_COMPLETED, 1244 baseSnapshot.DBRecordVersion+1, 1245 ) 1246 newSnapshot := RandomSnapshot( 1247 s.NamespaceID, 1248 s.WorkflowID, 1249 uuid.New().String(), 1250 rand.Int63(), 1251 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 1252 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1253 rand.Int63(), 1254 ) 1255 _, err := s.ExecutionManager.ConflictResolveWorkflowExecution(s.Ctx, &p.ConflictResolveWorkflowExecutionRequest{ 1256 ShardID: s.ShardID, 1257 RangeID: s.RangeID, 1258 Mode: p.ConflictResolveWorkflowModeUpdateCurrent, 1259 1260 ResetWorkflowSnapshot: *resetSnapshot, 1261 ResetWorkflowEvents: nil, 1262 1263 NewWorkflowSnapshot: newSnapshot, 1264 NewWorkflowEvents: nil, 1265 1266 CurrentWorkflowMutation: nil, 1267 CurrentWorkflowEvents: nil, 1268 }) 1269 s.NoError(err) 1270 1271 s.AssertEqualWithDB(resetSnapshot) 1272 s.AssertEqualWithDB(newSnapshot) 1273 } 1274 1275 func (s *ExecutionMutableStateSuite) TestConflictResolve_Zombie() { 1276 _ = s.CreateWorkflow( 1277 rand.Int63(), 1278 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 1279 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1280 rand.Int63(), 1281 ) 1282 runID := uuid.New().String() 1283 baseSnapshot := RandomSnapshot( 1284 s.NamespaceID, 1285 s.WorkflowID, 1286 runID, 1287 rand.Int63(), 1288 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 1289 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1290 rand.Int63(), 1291 ) 1292 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 1293 ShardID: s.ShardID, 1294 RangeID: s.RangeID, 1295 Mode: p.CreateWorkflowModeBypassCurrent, 1296 1297 PreviousRunID: "", 1298 PreviousLastWriteVersion: 0, 1299 1300 NewWorkflowSnapshot: *baseSnapshot, 1301 NewWorkflowEvents: nil, 1302 }) 1303 s.NoError(err) 1304 1305 resetSnapshot := RandomSnapshot( 1306 s.NamespaceID, 1307 s.WorkflowID, 1308 runID, 1309 rand.Int63(), 1310 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 1311 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1312 baseSnapshot.DBRecordVersion+1, 1313 ) 1314 _, err = s.ExecutionManager.ConflictResolveWorkflowExecution(s.Ctx, &p.ConflictResolveWorkflowExecutionRequest{ 1315 ShardID: s.ShardID, 1316 RangeID: s.RangeID, 1317 Mode: p.ConflictResolveWorkflowModeBypassCurrent, 1318 1319 ResetWorkflowSnapshot: *resetSnapshot, 1320 ResetWorkflowEvents: nil, 1321 1322 NewWorkflowSnapshot: nil, 1323 NewWorkflowEvents: nil, 1324 1325 CurrentWorkflowMutation: nil, 1326 CurrentWorkflowEvents: nil, 1327 }) 1328 s.NoError(err) 1329 1330 s.AssertEqualWithDB(resetSnapshot) 1331 } 1332 1333 func (s *ExecutionMutableStateSuite) TestConflictResolve_Zombie_CurrentConflict() { 1334 baseSnapshot := s.CreateWorkflow( 1335 rand.Int63(), 1336 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 1337 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1338 rand.Int63(), 1339 ) 1340 1341 resetSnapshot := RandomSnapshot( 1342 s.NamespaceID, 1343 s.WorkflowID, 1344 s.RunID, 1345 rand.Int63(), 1346 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 1347 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1348 baseSnapshot.DBRecordVersion+1, 1349 ) 1350 _, err := s.ExecutionManager.ConflictResolveWorkflowExecution(s.Ctx, &p.ConflictResolveWorkflowExecutionRequest{ 1351 ShardID: s.ShardID, 1352 RangeID: s.RangeID, 1353 Mode: p.ConflictResolveWorkflowModeBypassCurrent, 1354 1355 ResetWorkflowSnapshot: *resetSnapshot, 1356 ResetWorkflowEvents: nil, 1357 1358 NewWorkflowSnapshot: nil, 1359 NewWorkflowEvents: nil, 1360 1361 CurrentWorkflowMutation: nil, 1362 CurrentWorkflowEvents: nil, 1363 }) 1364 s.IsType(&p.CurrentWorkflowConditionFailedError{}, err) 1365 1366 s.AssertEqualWithDB(baseSnapshot) 1367 } 1368 1369 func (s *ExecutionMutableStateSuite) TestConflictResolve_Zombie_Conflict() { 1370 _ = s.CreateWorkflow( 1371 rand.Int63(), 1372 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 1373 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1374 rand.Int63(), 1375 ) 1376 runID := uuid.New().String() 1377 baseSnapshot := RandomSnapshot( 1378 s.NamespaceID, 1379 s.WorkflowID, 1380 runID, 1381 rand.Int63(), 1382 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 1383 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1384 rand.Int63(), 1385 ) 1386 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 1387 ShardID: s.ShardID, 1388 RangeID: s.RangeID, 1389 Mode: p.CreateWorkflowModeBypassCurrent, 1390 1391 PreviousRunID: "", 1392 PreviousLastWriteVersion: 0, 1393 1394 NewWorkflowSnapshot: *baseSnapshot, 1395 NewWorkflowEvents: nil, 1396 }) 1397 s.NoError(err) 1398 1399 resetSnapshot := RandomSnapshot( 1400 s.NamespaceID, 1401 s.WorkflowID, 1402 runID, 1403 rand.Int63(), 1404 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 1405 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1406 rand.Int63(), 1407 ) 1408 _, err = s.ExecutionManager.ConflictResolveWorkflowExecution(s.Ctx, &p.ConflictResolveWorkflowExecutionRequest{ 1409 ShardID: s.ShardID, 1410 RangeID: s.RangeID, 1411 Mode: p.ConflictResolveWorkflowModeBypassCurrent, 1412 1413 ResetWorkflowSnapshot: *resetSnapshot, 1414 ResetWorkflowEvents: nil, 1415 1416 NewWorkflowSnapshot: nil, 1417 NewWorkflowEvents: nil, 1418 1419 CurrentWorkflowMutation: nil, 1420 CurrentWorkflowEvents: nil, 1421 }) 1422 s.IsType(&p.WorkflowConditionFailedError{}, err) 1423 1424 s.AssertEqualWithDB(baseSnapshot) 1425 } 1426 1427 func (s *ExecutionMutableStateSuite) TestConflictResolve_Zombie_WithNew() { 1428 _ = s.CreateWorkflow( 1429 rand.Int63(), 1430 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 1431 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1432 rand.Int63(), 1433 ) 1434 runID := uuid.New().String() 1435 baseSnapshot := RandomSnapshot( 1436 s.NamespaceID, 1437 s.WorkflowID, 1438 runID, 1439 rand.Int63(), 1440 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 1441 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1442 rand.Int63(), 1443 ) 1444 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 1445 ShardID: s.ShardID, 1446 RangeID: s.RangeID, 1447 Mode: p.CreateWorkflowModeBypassCurrent, 1448 1449 PreviousRunID: "", 1450 PreviousLastWriteVersion: 0, 1451 1452 NewWorkflowSnapshot: *baseSnapshot, 1453 NewWorkflowEvents: nil, 1454 }) 1455 s.NoError(err) 1456 1457 resetSnapshot := RandomSnapshot( 1458 s.NamespaceID, 1459 s.WorkflowID, 1460 runID, 1461 rand.Int63(), 1462 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED, 1463 enumspb.WORKFLOW_EXECUTION_STATUS_COMPLETED, 1464 baseSnapshot.DBRecordVersion+1, 1465 ) 1466 newSnapshot := RandomSnapshot( 1467 s.NamespaceID, 1468 s.WorkflowID, 1469 uuid.New().String(), 1470 rand.Int63(), 1471 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 1472 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1473 rand.Int63(), 1474 ) 1475 _, err = s.ExecutionManager.ConflictResolveWorkflowExecution(s.Ctx, &p.ConflictResolveWorkflowExecutionRequest{ 1476 ShardID: s.ShardID, 1477 RangeID: s.RangeID, 1478 Mode: p.ConflictResolveWorkflowModeBypassCurrent, 1479 1480 ResetWorkflowSnapshot: *resetSnapshot, 1481 ResetWorkflowEvents: nil, 1482 1483 NewWorkflowSnapshot: newSnapshot, 1484 NewWorkflowEvents: nil, 1485 1486 CurrentWorkflowMutation: nil, 1487 CurrentWorkflowEvents: nil, 1488 }) 1489 s.NoError(err) 1490 1491 s.AssertEqualWithDB(resetSnapshot) 1492 s.AssertEqualWithDB(newSnapshot) 1493 } 1494 1495 func (s *ExecutionMutableStateSuite) TestSet_NotExists() { 1496 setSnapshot := RandomSnapshot( 1497 s.NamespaceID, 1498 s.WorkflowID, 1499 s.RunID, 1500 rand.Int63(), 1501 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 1502 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1503 rand.Int63(), 1504 ) 1505 _, err := s.ExecutionManager.SetWorkflowExecution(s.Ctx, &p.SetWorkflowExecutionRequest{ 1506 ShardID: s.ShardID, 1507 RangeID: s.RangeID, 1508 1509 SetWorkflowSnapshot: *setSnapshot, 1510 }) 1511 s.IsType(&p.ConditionFailedError{}, err) 1512 1513 s.AssertMissingFromDB(s.NamespaceID, s.WorkflowID, s.RunID) 1514 } 1515 1516 func (s *ExecutionMutableStateSuite) TestSet_Conflict() { 1517 snapshot := s.CreateWorkflow( 1518 rand.Int63(), 1519 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 1520 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1521 rand.Int63(), 1522 ) 1523 1524 setSnapshot := RandomSnapshot( 1525 s.NamespaceID, 1526 s.WorkflowID, 1527 s.RunID, 1528 rand.Int63(), 1529 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 1530 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1531 rand.Int63(), 1532 ) 1533 _, err := s.ExecutionManager.SetWorkflowExecution(s.Ctx, &p.SetWorkflowExecutionRequest{ 1534 ShardID: s.ShardID, 1535 RangeID: s.RangeID, 1536 1537 SetWorkflowSnapshot: *setSnapshot, 1538 }) 1539 s.IsType(&p.WorkflowConditionFailedError{}, err) 1540 1541 s.AssertEqualWithDB(snapshot) 1542 } 1543 1544 func (s *ExecutionMutableStateSuite) TestSet() { 1545 snapshot := s.CreateWorkflow( 1546 rand.Int63(), 1547 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 1548 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1549 rand.Int63(), 1550 ) 1551 1552 setSnapshot := RandomSnapshot( 1553 s.NamespaceID, 1554 s.WorkflowID, 1555 s.RunID, 1556 rand.Int63(), 1557 enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING, 1558 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1559 snapshot.DBRecordVersion+1, 1560 ) 1561 _, err := s.ExecutionManager.SetWorkflowExecution(s.Ctx, &p.SetWorkflowExecutionRequest{ 1562 ShardID: s.ShardID, 1563 RangeID: s.RangeID, 1564 1565 SetWorkflowSnapshot: *setSnapshot, 1566 }) 1567 s.NoError(err) 1568 1569 s.AssertEqualWithDB(setSnapshot) 1570 } 1571 1572 func (s *ExecutionMutableStateSuite) TestDeleteCurrent_IsCurrent() { 1573 newSnapshot := s.CreateWorkflow( 1574 rand.Int63(), 1575 enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, 1576 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1577 rand.Int63(), 1578 ) 1579 1580 err := s.ExecutionManager.DeleteCurrentWorkflowExecution(s.Ctx, &p.DeleteCurrentWorkflowExecutionRequest{ 1581 ShardID: s.ShardID, 1582 NamespaceID: s.NamespaceID, 1583 WorkflowID: s.WorkflowID, 1584 RunID: s.RunID, 1585 }) 1586 s.NoError(err) 1587 1588 _, err = s.ExecutionManager.GetCurrentExecution(s.Ctx, &p.GetCurrentExecutionRequest{ 1589 ShardID: s.ShardID, 1590 NamespaceID: s.NamespaceID, 1591 WorkflowID: s.WorkflowID, 1592 }) 1593 s.IsType(&serviceerror.NotFound{}, err) 1594 1595 s.AssertEqualWithDB(newSnapshot) 1596 } 1597 1598 func (s *ExecutionMutableStateSuite) TestDeleteCurrent_NotCurrent() { 1599 newSnapshot := RandomSnapshot( 1600 s.NamespaceID, 1601 s.WorkflowID, 1602 s.RunID, 1603 rand.Int63(), 1604 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 1605 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1606 rand.Int63(), 1607 ) 1608 1609 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 1610 ShardID: s.ShardID, 1611 RangeID: s.RangeID, 1612 Mode: p.CreateWorkflowModeBypassCurrent, 1613 1614 PreviousRunID: "", 1615 PreviousLastWriteVersion: 0, 1616 1617 NewWorkflowSnapshot: *newSnapshot, 1618 NewWorkflowEvents: nil, 1619 }) 1620 s.NoError(err) 1621 1622 err = s.ExecutionManager.DeleteCurrentWorkflowExecution(s.Ctx, &p.DeleteCurrentWorkflowExecutionRequest{ 1623 ShardID: s.ShardID, 1624 NamespaceID: s.NamespaceID, 1625 WorkflowID: s.WorkflowID, 1626 RunID: s.RunID, 1627 }) 1628 s.NoError(err) 1629 1630 _, err = s.ExecutionManager.GetCurrentExecution(s.Ctx, &p.GetCurrentExecutionRequest{ 1631 ShardID: s.ShardID, 1632 NamespaceID: s.NamespaceID, 1633 WorkflowID: s.WorkflowID, 1634 }) 1635 s.IsType(&serviceerror.NotFound{}, err) 1636 1637 s.AssertEqualWithDB(newSnapshot) 1638 } 1639 1640 func (s *ExecutionMutableStateSuite) TestDelete_Exists() { 1641 newSnapshot := RandomSnapshot( 1642 s.NamespaceID, 1643 s.WorkflowID, 1644 s.RunID, 1645 rand.Int63(), 1646 enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE, 1647 enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING, 1648 rand.Int63(), 1649 ) 1650 1651 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 1652 ShardID: s.ShardID, 1653 RangeID: s.RangeID, 1654 Mode: p.CreateWorkflowModeBypassCurrent, 1655 1656 PreviousRunID: "", 1657 PreviousLastWriteVersion: 0, 1658 1659 NewWorkflowSnapshot: *newSnapshot, 1660 NewWorkflowEvents: nil, 1661 }) 1662 s.NoError(err) 1663 1664 err = s.ExecutionManager.DeleteWorkflowExecution(s.Ctx, &p.DeleteWorkflowExecutionRequest{ 1665 ShardID: s.ShardID, 1666 NamespaceID: s.NamespaceID, 1667 WorkflowID: s.WorkflowID, 1668 RunID: s.RunID, 1669 }) 1670 s.NoError(err) 1671 1672 s.AssertMissingFromDB(s.NamespaceID, s.WorkflowID, s.RunID) 1673 } 1674 1675 func (s *ExecutionMutableStateSuite) TestDelete_NotExists() { 1676 err := s.ExecutionManager.DeleteWorkflowExecution(s.Ctx, &p.DeleteWorkflowExecutionRequest{ 1677 ShardID: s.ShardID, 1678 NamespaceID: s.NamespaceID, 1679 WorkflowID: s.WorkflowID, 1680 RunID: s.RunID, 1681 }) 1682 s.NoError(err) 1683 1684 s.AssertMissingFromDB(s.NamespaceID, s.WorkflowID, s.RunID) 1685 } 1686 1687 func (s *ExecutionMutableStateSuite) CreateWorkflow( 1688 lastWriteVersion int64, 1689 state enumsspb.WorkflowExecutionState, 1690 status enumspb.WorkflowExecutionStatus, 1691 dbRecordVersion int64, 1692 ) *p.WorkflowSnapshot { 1693 snapshot := RandomSnapshot( 1694 s.NamespaceID, 1695 s.WorkflowID, 1696 s.RunID, 1697 lastWriteVersion, 1698 state, 1699 status, 1700 dbRecordVersion, 1701 ) 1702 _, err := s.ExecutionManager.CreateWorkflowExecution(s.Ctx, &p.CreateWorkflowExecutionRequest{ 1703 ShardID: s.ShardID, 1704 RangeID: s.RangeID, 1705 Mode: p.CreateWorkflowModeBrandNew, 1706 1707 PreviousRunID: "", 1708 PreviousLastWriteVersion: 0, 1709 1710 NewWorkflowSnapshot: *snapshot, 1711 NewWorkflowEvents: nil, 1712 }) 1713 s.NoError(err) 1714 return snapshot 1715 } 1716 1717 func (s *ExecutionMutableStateSuite) AssertMissingFromDB( 1718 namespaceID string, 1719 workflowID string, 1720 runID string, 1721 ) { 1722 _, err := s.ExecutionManager.GetWorkflowExecution(s.Ctx, &p.GetWorkflowExecutionRequest{ 1723 ShardID: s.ShardID, 1724 NamespaceID: namespaceID, 1725 WorkflowID: workflowID, 1726 RunID: runID, 1727 }) 1728 s.IsType(&serviceerror.NotFound{}, err) 1729 } 1730 1731 func (s *ExecutionMutableStateSuite) AssertEqualWithDB( 1732 snapshot *p.WorkflowSnapshot, 1733 mutations ...*p.WorkflowMutation, 1734 ) { 1735 resp, err := s.ExecutionManager.GetWorkflowExecution(s.Ctx, &p.GetWorkflowExecutionRequest{ 1736 ShardID: s.ShardID, 1737 NamespaceID: snapshot.ExecutionInfo.NamespaceId, 1738 WorkflowID: snapshot.ExecutionInfo.WorkflowId, 1739 RunID: snapshot.ExecutionState.RunId, 1740 }) 1741 s.NoError(err) 1742 1743 actualMutableState := resp.State 1744 actualDBRecordVersion := resp.DBRecordVersion 1745 1746 expectedMutableState, expectedDBRecordVersion := s.Accumulate(snapshot, mutations...) 1747 1748 // need to special handling signal request IDs ... 1749 // since ^ is slice 1750 s.Equal( 1751 convert.StringSliceToSet(expectedMutableState.SignalRequestedIds), 1752 convert.StringSliceToSet(actualMutableState.SignalRequestedIds), 1753 ) 1754 actualMutableState.SignalRequestedIds = expectedMutableState.SignalRequestedIds 1755 1756 s.Equal(expectedDBRecordVersion, actualDBRecordVersion) 1757 s.ProtoEqual(expectedMutableState, actualMutableState) 1758 } 1759 1760 func (s *ExecutionMutableStateSuite) Accumulate( 1761 snapshot *p.WorkflowSnapshot, 1762 mutations ...*p.WorkflowMutation, 1763 ) (*persistencespb.WorkflowMutableState, int64) { 1764 mutableState := &persistencespb.WorkflowMutableState{ 1765 ExecutionInfo: snapshot.ExecutionInfo, 1766 ExecutionState: snapshot.ExecutionState, 1767 NextEventId: snapshot.NextEventID, 1768 ActivityInfos: snapshot.ActivityInfos, 1769 TimerInfos: snapshot.TimerInfos, 1770 ChildExecutionInfos: snapshot.ChildExecutionInfos, 1771 RequestCancelInfos: snapshot.RequestCancelInfos, 1772 SignalInfos: snapshot.SignalInfos, 1773 SignalRequestedIds: convert.StringSetToSlice(snapshot.SignalRequestedIDs), 1774 } 1775 dbRecordVersion := snapshot.DBRecordVersion 1776 1777 for _, mutation := range mutations { 1778 s.Equal(dbRecordVersion, mutation.DBRecordVersion-1) 1779 dbRecordVersion = mutation.DBRecordVersion 1780 1781 mutableState.ExecutionInfo = mutation.ExecutionInfo 1782 mutableState.ExecutionState = mutation.ExecutionState 1783 1784 mutableState.NextEventId = mutation.NextEventID 1785 1786 // activity infos 1787 for key, info := range mutation.UpsertActivityInfos { 1788 mutableState.ActivityInfos[key] = info 1789 } 1790 for key := range mutation.DeleteActivityInfos { 1791 delete(mutableState.ActivityInfos, key) 1792 } 1793 1794 // timer infos 1795 for key, info := range mutation.UpsertTimerInfos { 1796 mutableState.TimerInfos[key] = info 1797 } 1798 for key := range mutation.DeleteTimerInfos { 1799 delete(mutableState.TimerInfos, key) 1800 } 1801 1802 // child workflow infos 1803 for key, info := range mutation.UpsertChildExecutionInfos { 1804 mutableState.ChildExecutionInfos[key] = info 1805 } 1806 for key := range mutation.DeleteChildExecutionInfos { 1807 delete(mutableState.ChildExecutionInfos, key) 1808 } 1809 1810 // request cancel infos 1811 for key, info := range mutation.UpsertRequestCancelInfos { 1812 mutableState.RequestCancelInfos[key] = info 1813 } 1814 for key := range mutation.DeleteRequestCancelInfos { 1815 delete(mutableState.RequestCancelInfos, key) 1816 } 1817 1818 // signal infos 1819 for key, info := range mutation.UpsertSignalInfos { 1820 mutableState.SignalInfos[key] = info 1821 } 1822 for key := range mutation.DeleteSignalInfos { 1823 delete(mutableState.SignalInfos, key) 1824 } 1825 1826 // signal request IDs 1827 signalRequestIDs := convert.StringSliceToSet(mutableState.SignalRequestedIds) 1828 for key, info := range mutation.UpsertSignalRequestedIDs { 1829 signalRequestIDs[key] = info 1830 } 1831 for key := range mutation.DeleteSignalRequestedIDs { 1832 delete(signalRequestIDs, key) 1833 } 1834 mutableState.SignalRequestedIds = convert.StringSetToSlice(signalRequestIDs) 1835 1836 // buffered events 1837 if mutation.ClearBufferedEvents { 1838 mutableState.BufferedEvents = nil 1839 } else if mutation.NewBufferedEvents != nil { 1840 mutableState.BufferedEvents = append(mutableState.BufferedEvents, mutation.NewBufferedEvents...) 1841 } 1842 } 1843 1844 // need to serialize & deserialize to get rid of timezone information ... 1845 bytes, err := proto.Marshal(mutableState) 1846 s.NoError(err) 1847 mutableState = &persistencespb.WorkflowMutableState{} 1848 err = proto.Unmarshal(bytes, mutableState) 1849 s.NoError(err) 1850 1851 // make equal test easier 1852 if mutableState.ActivityInfos == nil { 1853 mutableState.ActivityInfos = make(map[int64]*persistencespb.ActivityInfo) 1854 } 1855 if mutableState.TimerInfos == nil { 1856 mutableState.TimerInfos = make(map[string]*persistencespb.TimerInfo) 1857 } 1858 if mutableState.ChildExecutionInfos == nil { 1859 mutableState.ChildExecutionInfos = make(map[int64]*persistencespb.ChildExecutionInfo) 1860 } 1861 if mutableState.RequestCancelInfos == nil { 1862 mutableState.RequestCancelInfos = make(map[int64]*persistencespb.RequestCancelInfo) 1863 } 1864 if mutableState.SignalInfos == nil { 1865 mutableState.SignalInfos = make(map[int64]*persistencespb.SignalInfo) 1866 } 1867 if mutableState.SignalRequestedIds == nil { 1868 mutableState.SignalRequestedIds = make([]string, 0) 1869 } 1870 if mutableState.BufferedEvents == nil { 1871 mutableState.BufferedEvents = make([]*historypb.HistoryEvent, 0) 1872 } 1873 1874 return mutableState, dbRecordVersion 1875 }