dispatch.rs (39167B)
1 //! Each job has an isolated polling frame on the existing bounded worker. 2 use super::*; 3 use core::{future::Future, pin::Pin}; 4 5 pub(super) fn run<'a>( 6 job: Job, 7 kind: Kind, 8 turn: stock::inventory::Turn<'a>, 9 ) -> Pin<Box<dyn Future<Output = ()> + 'a>> { 10 let stock::inventory::Turn { 11 connection, 12 namespace, 13 selected: input, 14 crypto, 15 clock, 16 uncertain, 17 } = turn; 18 match job { 19 Job::ChangeStockGrant(change, proof, reply) => Box::pin(async move { 20 let result = if kind == Kind::SellerStock && !*uncertain { 21 stock::grants::change( 22 &mut stock::inventory::Turn { 23 connection, 24 namespace, 25 selected: input, 26 crypto, 27 clock, 28 uncertain, 29 }, 30 *change, 31 proof, 32 ) 33 .await 34 } else { 35 Err(WorkspaceError::RecoveryRequired) 36 }; 37 let _ = reply.send(result); 38 }), 39 Job::ExecuteInventory(request, proof, reply) => Box::pin(async move { 40 let result = if kind == Kind::SellerStock { 41 stock::inventory::Turn { 42 connection, 43 namespace, 44 selected: input, 45 crypto, 46 clock, 47 uncertain, 48 } 49 .create(*request, proof) 50 .await 51 } else { 52 Err(OperationError::UnsupportedOperation) 53 }; 54 let _ = reply.send(result); 55 }), 56 Job::InventoryOperation(binding, minimum, operation, digest, proof, reply) => { 57 Box::pin(async move { 58 let result = if kind == Kind::SellerStock { 59 stock::inventory::Turn { 60 connection, 61 namespace, 62 selected: input, 63 crypto, 64 clock, 65 uncertain, 66 } 67 .creation(*binding, minimum, operation, digest, proof) 68 .await 69 } else { 70 Err(OperationError::UnsupportedOperation) 71 }; 72 let _ = reply.send(result); 73 }) 74 } 75 Job::IssueStockConsent(binding, minimum, capture, proof, reply) => Box::pin(async move { 76 let result = if kind == Kind::SellerStock { 77 stock::consent::issue( 78 &mut stock::inventory::Turn { 79 connection, 80 namespace, 81 selected: input, 82 crypto, 83 clock, 84 uncertain, 85 }, 86 *binding, 87 minimum, 88 *capture, 89 proof, 90 ) 91 .await 92 } else { 93 Err(OperationError::UnsupportedOperation) 94 }; 95 let _ = reply.send(result); 96 }), 97 Job::StockConsent(binding, minimum, operation, subject, proof, reply) => { 98 Box::pin(async move { 99 let result = if kind == Kind::SellerStock { 100 stock::consent::query( 101 &mut stock::inventory::Turn { 102 connection, 103 namespace, 104 selected: input, 105 crypto, 106 clock, 107 uncertain, 108 }, 109 *binding, 110 minimum, 111 operation, 112 subject, 113 proof, 114 ) 115 .await 116 } else { 117 Err(OperationError::UnsupportedOperation) 118 }; 119 let _ = reply.send(result); 120 }) 121 } 122 Job::RetainStockListing(binding, minimum, capture, proof, reply) => Box::pin(async move { 123 let result = if kind == Kind::SellerStock { 124 stock::public_source::retain( 125 &mut stock::inventory::Turn { 126 connection, 127 namespace, 128 selected: input, 129 crypto, 130 clock, 131 uncertain, 132 }, 133 *binding, 134 minimum, 135 *capture, 136 proof, 137 ) 138 .await 139 } else { 140 Err(OperationError::UnsupportedOperation) 141 }; 142 let _ = reply.send(result); 143 }), 144 Job::StockListing(binding, minimum, lookup, proof, reply) => Box::pin(async move { 145 let result = if kind == Kind::SellerStock { 146 stock::public_source::query( 147 &mut stock::inventory::Turn { 148 connection, 149 namespace, 150 selected: input, 151 crypto, 152 clock, 153 uncertain, 154 }, 155 *binding, 156 minimum, 157 lookup, 158 proof, 159 ) 160 .await 161 } else { 162 Err(OperationError::UnsupportedOperation) 163 }; 164 let _ = reply.send(result); 165 }), 166 Job::RetainStockSource(binding, minimum, capture, proof, reply) => Box::pin(async move { 167 let result = if kind == Kind::SellerStock { 168 stock::source::retain( 169 &mut stock::inventory::Turn { 170 connection, 171 namespace, 172 selected: input, 173 crypto, 174 clock, 175 uncertain, 176 }, 177 *binding, 178 minimum, 179 *capture, 180 proof, 181 ) 182 .await 183 } else { 184 Err(OperationError::UnsupportedOperation) 185 }; 186 let _ = reply.send(result); 187 }), 188 Job::InstallStockAgreement(request, proof, reply) => Box::pin(async move { 189 let result = if kind == Kind::SellerStock { 190 Box::pin(stock::inventory::installation::install( 191 &mut stock::inventory::Turn { 192 connection, 193 namespace, 194 selected: input, 195 crypto, 196 clock, 197 uncertain, 198 }, 199 *request, 200 proof, 201 )) 202 .await 203 } else { 204 Err(OperationError::UnsupportedOperation) 205 }; 206 let _ = reply.send(result); 207 }), 208 Job::StockAgreementInstallation(request, proof, reply) => Box::pin(async move { 209 let result = if kind == Kind::SellerStock { 210 Box::pin(stock::inventory::installation::read( 211 &mut stock::inventory::Turn { 212 connection, 213 namespace, 214 selected: input, 215 crypto, 216 clock, 217 uncertain, 218 }, 219 *request, 220 proof, 221 )) 222 .await 223 } else { 224 Err(OperationError::UnsupportedOperation) 225 }; 226 let _ = reply.send(result); 227 }), 228 Job::AbortStockPreparation(request, proof, reply) => Box::pin(async move { 229 let result = if kind == Kind::SellerStock { 230 Box::pin(stock::inventory::abort::abort( 231 &mut stock::inventory::Turn { 232 connection, 233 namespace, 234 selected: input, 235 crypto, 236 clock, 237 uncertain, 238 }, 239 *request, 240 proof, 241 )) 242 .await 243 } else { 244 Err(OperationError::UnsupportedOperation) 245 }; 246 let _ = reply.send(result); 247 }), 248 Job::StockPreparationAbort(request, proof, reply) => Box::pin(async move { 249 let result = if kind == Kind::SellerStock { 250 Box::pin(stock::inventory::abort::read( 251 &mut stock::inventory::Turn { 252 connection, 253 namespace, 254 selected: input, 255 crypto, 256 clock, 257 uncertain, 258 }, 259 *request, 260 proof, 261 )) 262 .await 263 } else { 264 Err(OperationError::UnsupportedOperation) 265 }; 266 let _ = reply.send(result); 267 }), 268 Job::StockSnapshot(request, proof, reply) => Box::pin(async move { 269 let result = if kind == Kind::SellerStock { 270 Box::pin(stock::snapshot::read( 271 &mut stock::inventory::Turn { 272 connection, 273 namespace, 274 selected: input, 275 crypto, 276 clock, 277 uncertain, 278 }, 279 *request, 280 proof, 281 )) 282 .await 283 } else { 284 Err(OperationError::UnsupportedOperation) 285 }; 286 let _ = reply.send(result); 287 }), 288 Job::StockEvidencePage(request, after, proof, reply) => Box::pin(async move { 289 let result = if kind == Kind::SellerStock { 290 Box::pin(stock::issuance::evidence::page( 291 &mut stock::inventory::Turn { 292 connection, 293 namespace, 294 selected: input, 295 crypto, 296 clock, 297 uncertain, 298 }, 299 *request, 300 after, 301 proof, 302 )) 303 .await 304 } else { 305 Err(OperationError::UnsupportedOperation) 306 }; 307 let _ = reply.send(result); 308 }), 309 Job::CaptureStockUnissued(request, proof, reply) => Box::pin(async move { 310 let result = if kind == Kind::SellerStock { 311 Box::pin(stock::issuance::unissued::capture( 312 &mut stock::inventory::Turn { 313 connection, 314 namespace, 315 selected: input, 316 crypto, 317 clock, 318 uncertain, 319 }, 320 *request, 321 proof, 322 )) 323 .await 324 } else { 325 Err(OperationError::UnsupportedOperation) 326 }; 327 let _ = reply.send(result); 328 }), 329 Job::StockUnissued(request, proof, reply) => Box::pin(async move { 330 let result = if kind == Kind::SellerStock { 331 Box::pin(stock::issuance::unissued::read( 332 &mut stock::inventory::Turn { 333 connection, 334 namespace, 335 selected: input, 336 crypto, 337 clock, 338 uncertain, 339 }, 340 *request, 341 proof, 342 )) 343 .await 344 } else { 345 Err(OperationError::UnsupportedOperation) 346 }; 347 let _ = reply.send(result); 348 }), 349 Job::PrepareStockDelivery(request, proof, reply) => Box::pin(async move { 350 let result = if kind == Kind::SellerStock { 351 Box::pin(stock::delivery::prepare( 352 &mut stock::inventory::Turn { 353 connection, 354 namespace, 355 selected: input, 356 crypto, 357 clock, 358 uncertain, 359 }, 360 *request, 361 proof, 362 )) 363 .await 364 } else { 365 Err(OperationError::UnsupportedOperation) 366 }; 367 let _ = reply.send(result); 368 }), 369 Job::StockDeliveryAttempt(request, request_id, proof, reply) => Box::pin(async move { 370 let result = if kind == Kind::SellerStock { 371 Box::pin(stock::delivery::query_attempt( 372 &mut stock::inventory::Turn { 373 connection, 374 namespace, 375 selected: input, 376 crypto, 377 clock, 378 uncertain, 379 }, 380 *request, 381 request_id, 382 proof, 383 )) 384 .await 385 } else { 386 Err(OperationError::UnsupportedOperation) 387 }; 388 let _ = reply.send(result); 389 }), 390 Job::StockDeliverySummary(request, proof, reply) => Box::pin(async move { 391 let result = if kind == Kind::SellerStock { 392 Box::pin(stock::delivery::summary( 393 &mut stock::inventory::Turn { 394 connection, 395 namespace, 396 selected: input, 397 crypto, 398 clock, 399 uncertain, 400 }, 401 *request, 402 proof, 403 )) 404 .await 405 } else { 406 Err(OperationError::UnsupportedOperation) 407 }; 408 let _ = reply.send(result); 409 }), 410 Job::RecordStockDeliveryObservation(binding, proof, observation, reply) => { 411 Box::pin(async move { 412 let result = if kind == Kind::SellerStock { 413 Box::pin(stock::delivery::capture_observation( 414 &mut stock::inventory::Turn { 415 connection, 416 namespace, 417 selected: input, 418 crypto, 419 clock, 420 uncertain, 421 }, 422 *binding, 423 proof, 424 *observation, 425 )) 426 .await 427 } else { 428 Err(OperationError::UnsupportedOperation) 429 }; 430 let _ = reply.send(result); 431 }) 432 } 433 Job::StockDeliveryObservations(request, after, proof, reply) => Box::pin(async move { 434 let result = if kind == Kind::SellerStock { 435 Box::pin(stock::delivery::page( 436 &mut stock::inventory::Turn { 437 connection, 438 namespace, 439 selected: input, 440 crypto, 441 clock, 442 uncertain, 443 }, 444 *request, 445 after, 446 proof, 447 )) 448 .await 449 } else { 450 Err(OperationError::UnsupportedOperation) 451 }; 452 let _ = reply.send(result); 453 }), 454 Job::CaptureStockEnvelope(request, proof, candidate, reply) => Box::pin(async move { 455 let result = if kind == Kind::SellerStock { 456 Box::pin(stock::envelope::capture_obtained( 457 &mut stock::inventory::Turn { 458 connection, 459 namespace, 460 selected: input, 461 crypto, 462 clock, 463 uncertain, 464 }, 465 request, 466 proof, 467 *candidate, 468 )) 469 .await 470 } else { 471 Err(OperationError::UnsupportedOperation) 472 }; 473 let _ = reply.send(result); 474 }), 475 Job::StockEnvelope(request, proof, reply) => Box::pin(async move { 476 let result = if kind == Kind::SellerStock { 477 Box::pin(stock::envelope::read( 478 &mut stock::inventory::Turn { 479 connection, 480 namespace, 481 selected: input, 482 crypto, 483 clock, 484 uncertain, 485 }, 486 *request, 487 proof, 488 )) 489 .await 490 } else { 491 Err(OperationError::UnsupportedOperation) 492 }; 493 let _ = reply.send(result); 494 }), 495 Job::StockRewrapAttempt(request, proof, reply) => Box::pin(async move { 496 let result = if kind == Kind::SellerStock { 497 Box::pin(stock::envelope::rewrap_attempt( 498 &mut stock::inventory::Turn { 499 connection, 500 namespace, 501 selected: input, 502 crypto, 503 clock, 504 uncertain, 505 }, 506 *request, 507 proof, 508 )) 509 .await 510 } else { 511 Err(OperationError::UnsupportedOperation) 512 }; 513 let _ = reply.send(result); 514 }), 515 Job::PrepareStockRewrap(request, proof, reply) => Box::pin(async move { 516 let result = if kind == Kind::SellerStock { 517 Box::pin(stock::envelope::prepare_rewrap( 518 &mut stock::inventory::Turn { 519 connection, 520 namespace, 521 selected: input, 522 crypto, 523 clock, 524 uncertain, 525 }, 526 *request, 527 proof, 528 )) 529 .await 530 } else { 531 Err(OperationError::UnsupportedOperation) 532 }; 533 let _ = reply.send(result); 534 }), 535 Job::StockRewraps(request, after, proof, reply) => Box::pin(async move { 536 let result = if kind == Kind::SellerStock { 537 Box::pin(stock::envelope::page( 538 &mut stock::inventory::Turn { 539 connection, 540 namespace, 541 selected: input, 542 crypto, 543 clock, 544 uncertain, 545 }, 546 *request, 547 after, 548 proof, 549 )) 550 .await 551 } else { 552 Err(OperationError::UnsupportedOperation) 553 }; 554 let _ = reply.send(result); 555 }), 556 Job::CaptureStockEvidence(evidence, proof, reply) => Box::pin(async move { 557 let result = if kind == Kind::SellerStock { 558 Box::pin(stock::issuance::evidence::capture( 559 &mut stock::inventory::Turn { 560 connection, 561 namespace, 562 selected: input, 563 crypto, 564 clock, 565 uncertain, 566 }, 567 *evidence, 568 proof, 569 )) 570 .await 571 } else { 572 Err(OperationError::UnsupportedOperation) 573 }; 574 let _ = reply.send(result); 575 }), 576 Job::StockEvidence(request, digest, proof, reply) => Box::pin(async move { 577 let result = if kind == Kind::SellerStock { 578 Box::pin(stock::issuance::evidence::read( 579 &mut stock::inventory::Turn { 580 connection, 581 namespace, 582 selected: input, 583 crypto, 584 clock, 585 uncertain, 586 }, 587 *request, 588 digest, 589 proof, 590 )) 591 .await 592 } else { 593 Err(OperationError::UnsupportedOperation) 594 }; 595 let _ = reply.send(result); 596 }), 597 Job::ClaimStockSigning(request, proof, reply) => Box::pin(async move { 598 let result = if kind == Kind::SellerStock { 599 Box::pin(stock::issuance::claim::claim( 600 &mut stock::inventory::Turn { 601 connection, 602 namespace, 603 selected: input, 604 crypto, 605 clock, 606 uncertain, 607 }, 608 *request, 609 proof, 610 )) 611 .await 612 } else { 613 Err(OperationError::UnsupportedOperation) 614 }; 615 let _ = reply.send(result); 616 }), 617 Job::AuthorizeStockExactReplay(request, proof, reply) => Box::pin(async move { 618 let result = if kind == Kind::SellerStock { 619 Box::pin(stock::issuance::recovery::authorize( 620 &mut stock::inventory::Turn { 621 connection, 622 namespace, 623 selected: input, 624 crypto, 625 clock, 626 uncertain, 627 }, 628 *request, 629 proof, 630 )) 631 .await 632 } else { 633 Err(OperationError::UnsupportedOperation) 634 }; 635 let _ = reply.send(result); 636 }), 637 Job::StockSigningAttempt(request, proof, reply) => Box::pin(async move { 638 let result = if kind == Kind::SellerStock { 639 Box::pin(stock::issuance::claim::read( 640 &mut stock::inventory::Turn { 641 connection, 642 namespace, 643 selected: input, 644 crypto, 645 clock, 646 uncertain, 647 }, 648 *request, 649 proof, 650 )) 651 .await 652 } else { 653 Err(OperationError::UnsupportedOperation) 654 }; 655 let _ = reply.send(result); 656 }), 657 Job::BindStockSigningPlan(request, proof, reply) => Box::pin(async move { 658 let result = if kind == Kind::SellerStock { 659 Box::pin(stock::signing_plan::bind( 660 &mut stock::inventory::Turn { 661 connection, 662 namespace, 663 selected: input, 664 crypto, 665 clock, 666 uncertain, 667 }, 668 *request, 669 proof, 670 )) 671 .await 672 } else { 673 Err(OperationError::UnsupportedOperation) 674 }; 675 let _ = reply.send(result); 676 }), 677 Job::StockSigningPlan(binding, minimum, operation, digest, proof, reply) => { 678 Box::pin(async move { 679 let result = if kind == Kind::SellerStock { 680 Box::pin(stock::signing_plan::read( 681 &mut stock::inventory::Turn { 682 connection, 683 namespace, 684 selected: input, 685 crypto, 686 clock, 687 uncertain, 688 }, 689 *binding, 690 minimum, 691 operation, 692 digest, 693 proof, 694 )) 695 .await 696 } else { 697 Err(OperationError::UnsupportedOperation) 698 }; 699 let _ = reply.send(result); 700 }) 701 } 702 Job::PrepareStockAcceptance(request, proof, reply) => Box::pin(async move { 703 let result = if kind == Kind::SellerStock { 704 Box::pin(stock::inventory::acceptance::admit( 705 &mut stock::inventory::Turn { 706 connection, 707 namespace, 708 selected: input, 709 crypto, 710 clock, 711 uncertain, 712 }, 713 *request, 714 proof, 715 )) 716 .await 717 } else { 718 Err(OperationError::UnsupportedOperation) 719 }; 720 let _ = reply.send(result); 721 }), 722 Job::StockOrderRequest( 723 binding, 724 inventory_minimum, 725 minimum, 726 listings, 727 selected, 728 proof, 729 reply, 730 ) => Box::pin(async move { 731 let result = if kind == Kind::SellerStock { 732 Box::pin(stock::source::inspect_request( 733 &mut stock::inventory::Turn { 734 connection, 735 namespace, 736 selected: input, 737 crypto, 738 clock, 739 uncertain, 740 }, 741 *binding, 742 inventory_minimum, 743 minimum, 744 listings, 745 selected, 746 proof, 747 )) 748 .await 749 } else { 750 Err(OperationError::UnsupportedOperation) 751 }; 752 let _ = reply.send(result); 753 }), 754 Job::StockOrderHistory( 755 binding, 756 inventory_minimum, 757 minimum, 758 listings, 759 scope, 760 proof, 761 reply, 762 ) => Box::pin(async move { 763 let result = if kind == Kind::SellerStock { 764 Box::pin(stock::source::query_history( 765 &mut stock::inventory::Turn { 766 connection, 767 namespace, 768 selected: input, 769 crypto, 770 clock, 771 uncertain, 772 }, 773 *binding, 774 inventory_minimum, 775 minimum, 776 listings, 777 scope, 778 proof, 779 )) 780 .await 781 } else { 782 Err(OperationError::UnsupportedOperation) 783 }; 784 let _ = reply.send(result); 785 }), 786 Job::StockSource(binding, minimum, envelope, proof, reply) => Box::pin(async move { 787 let result = if kind == Kind::SellerStock { 788 stock::source::query( 789 &mut stock::inventory::Turn { 790 connection, 791 namespace, 792 selected: input, 793 crypto, 794 clock, 795 uncertain, 796 }, 797 *binding, 798 minimum, 799 envelope, 800 proof, 801 ) 802 .await 803 } else { 804 Err(OperationError::UnsupportedOperation) 805 }; 806 let _ = reply.send(result); 807 }), 808 Job::OptionMapping(binding, minimum, key, proof, reply) => Box::pin(async move { 809 let result = if kind == Kind::SellerStock { 810 stock::inventory::Turn { 811 connection, 812 namespace, 813 selected: input, 814 crypto, 815 clock, 816 uncertain, 817 } 818 .option_mapping(*binding, minimum, key, proof) 819 .await 820 } else { 821 Err(OperationError::UnsupportedOperation) 822 }; 823 let _ = reply.send(result); 824 }), 825 Job::InspectStock(binding, minimum, id, proof, reply) => Box::pin(async move { 826 let result = if kind == Kind::SellerStock { 827 stock::inventory::Turn { 828 connection, 829 namespace, 830 selected: input, 831 crypto, 832 clock, 833 uncertain, 834 } 835 .inspect(*binding, minimum, id, proof) 836 .await 837 } else { 838 Err(OperationError::UnsupportedOperation) 839 }; 840 let _ = reply.send(result); 841 }), 842 Job::Pool(binding, minimum, id, proof, reply) => Box::pin(async move { 843 let result = if kind == Kind::SellerStock { 844 stock::inventory::Turn { 845 connection, 846 namespace, 847 selected: input, 848 crypto, 849 clock, 850 uncertain, 851 } 852 .pool(*binding, minimum, id, proof) 853 .await 854 } else { 855 Err(OperationError::UnsupportedOperation) 856 }; 857 let _ = reply.send(result); 858 }), 859 Job::StockAuthority(selected, proof, reply) => Box::pin(async move { 860 let result = if kind == Kind::SellerStock && !*uncertain { 861 stock::authenticate( 862 connection, namespace, input, crypto, clock, &selected, &proof, 863 ) 864 .await 865 .map(|(receipt, _)| receipt) 866 } else { 867 Err(WorkspaceError::RecoveryRequired) 868 }; 869 if result == Err(WorkspaceError::CommitUnknown) { 870 *uncertain = true; 871 } 872 let _ = reply.send(result); 873 }), 874 job @ (Job::RecoverStockRewrapAdmission(..) 875 | Job::RecoverStockEnvelope(..) 876 | Job::RecoverStockObservation(..) 877 | Job::RecoverCapture(..) 878 | Job::RecoverStockEvidence(..) 879 | Job::RecoverStockUnissued(..)) => Box::pin(async move { job.reject_recovery() }), 880 Job::CaptureDeliveryObservation(binding, proof, observation, reply) => { 881 Box::pin(async move { 882 let result = Journal { 883 connection, 884 namespace, 885 selected: input, 886 crypto, 887 clock, 888 uncertain, 889 } 890 .capture_delivery_observation(*binding, proof, *observation) 891 .await; 892 let _ = reply.send(result); 893 }) 894 } 895 Job::QueryDeliveryObservations( 896 binding, 897 operation, 898 digest, 899 recipient, 900 request, 901 proof, 902 reply, 903 ) => Box::pin(async move { 904 let result = Journal { 905 connection, 906 namespace, 907 selected: input, 908 crypto, 909 clock, 910 uncertain, 911 } 912 .query_delivery_observations(*binding, operation, digest, recipient, request, proof) 913 .await; 914 let _ = reply.send(result); 915 }), 916 Job::PrepareDelivery(request, proof, candidate, reply) => Box::pin(async move { 917 let result = Journal { 918 connection, 919 namespace, 920 selected: input, 921 crypto, 922 clock, 923 uncertain, 924 } 925 .prepare_delivery(*request, proof, candidate.map(|value| *value)) 926 .await; 927 let _ = reply.send(result); 928 }), 929 Job::QueryDelivery(binding, operation, digest, recipient, request, proof, reply) => { 930 Box::pin(async move { 931 let result = Journal { 932 connection, 933 namespace, 934 selected: input, 935 crypto, 936 clock, 937 uncertain, 938 } 939 .query_delivery(*binding, operation, digest, recipient, request, proof) 940 .await; 941 let _ = reply.send(result); 942 }) 943 } 944 Job::Install(request, proof, reply) => Box::pin(async move { 945 let result = Journal { 946 connection, 947 namespace, 948 selected: input, 949 crypto, 950 clock, 951 uncertain, 952 } 953 .install_chat(*request, proof) 954 .await; 955 let _ = reply.send(result); 956 }), 957 Job::Snapshot(binding, operation, digest, proof, reply) => Box::pin(async move { 958 let result = Journal { 959 connection, 960 namespace, 961 selected: input, 962 crypto, 963 clock, 964 uncertain, 965 } 966 .query_snapshot(*binding, operation, digest, proof) 967 .await; 968 let _ = reply.send(result); 969 }), 970 Job::Claim(request, proof, reply) => Box::pin(async move { 971 let result = Journal { 972 connection, 973 namespace, 974 selected: input, 975 crypto, 976 clock, 977 uncertain, 978 } 979 .claim_issuance(*request, proof) 980 .await; 981 let _ = reply.send(result); 982 }), 983 Job::Attempt(request, proof, reply) => Box::pin(async move { 984 let result = Journal { 985 connection, 986 namespace, 987 selected: input, 988 crypto, 989 clock, 990 uncertain, 991 } 992 .query_issuance(*request, proof) 993 .await; 994 let _ = reply.send(result); 995 }), 996 Job::Capture(selected, proof, evidence, reply) => Box::pin(async move { 997 let result = Journal { 998 connection, 999 namespace, 1000 selected: input, 1001 crypto, 1002 clock, 1003 uncertain, 1004 } 1005 .capture_issuance(*selected, proof, *evidence) 1006 .await; 1007 let _ = reply.send(result); 1008 }), 1009 Job::Captured(request, proof, reply) => Box::pin(async move { 1010 let result = Journal { 1011 connection, 1012 namespace, 1013 selected: input, 1014 crypto, 1015 clock, 1016 uncertain, 1017 } 1018 .query_captured(*request, proof) 1019 .await; 1020 let _ = reply.send(result); 1021 }), 1022 Job::BindPlan(binding, plan, proof, reply) => Box::pin(async move { 1023 let result = Journal { 1024 connection, 1025 namespace, 1026 selected: input, 1027 crypto, 1028 clock, 1029 uncertain, 1030 } 1031 .bind_plan(*binding, plan, proof) 1032 .await; 1033 let _ = reply.send(result); 1034 }), 1035 Job::SigningPlan(binding, operation_id, digest, proof, reply) => Box::pin(async move { 1036 let result = Journal { 1037 connection, 1038 namespace, 1039 selected: input, 1040 crypto, 1041 clock, 1042 uncertain, 1043 } 1044 .query_plan(*binding, operation_id, digest, proof) 1045 .await; 1046 let _ = reply.send(result); 1047 }), 1048 Job::Authenticate(selected, proof, reply) => Box::pin(async move { 1049 let result = if *uncertain { 1050 Err(WorkspaceError::RecoveryRequired) 1051 } else if kind == Kind::SellerStock { 1052 stock::authenticate( 1053 connection, namespace, input, crypto, clock, &selected, &proof, 1054 ) 1055 .await 1056 .map(|(_, binding)| binding) 1057 } else { 1058 authenticate( 1059 connection, namespace, input, crypto, clock, &selected, &proof, 1060 ) 1061 .await 1062 .map(|(_, binding)| binding) 1063 }; 1064 if result == Err(WorkspaceError::CommitUnknown) { 1065 *uncertain = true; 1066 } 1067 let _ = reply.send(result); 1068 }), 1069 Job::Revoke(selected, proof, reply) => Box::pin(async move { 1070 let result = if *uncertain { 1071 Err(WorkspaceError::RecoveryRequired) 1072 } else if kind == Kind::SellerStock { 1073 stock::revoke( 1074 connection, namespace, input, crypto, clock, &selected, &proof, 1075 ) 1076 .await 1077 } else { 1078 revoke( 1079 connection, namespace, input, crypto, clock, &selected, &proof, 1080 ) 1081 .await 1082 }; 1083 if result == Err(WorkspaceError::CommitUnknown) { 1084 *uncertain = true; 1085 } 1086 let _ = reply.send(result); 1087 }), 1088 Job::Admit(request, proof, reply) => Box::pin(async move { 1089 let result = Journal { 1090 connection, 1091 namespace, 1092 selected: input, 1093 crypto, 1094 clock, 1095 uncertain, 1096 } 1097 .admit(*request, proof) 1098 .await; 1099 let _ = reply.send(result); 1100 }), 1101 Job::Operation(binding, operation_id, digest, proof, reply) => Box::pin(async move { 1102 let result = Journal { 1103 connection, 1104 namespace, 1105 selected: input, 1106 crypto, 1107 clock, 1108 uncertain, 1109 } 1110 .query(*binding, operation_id, digest, proof) 1111 .await; 1112 let _ = reply.send(result); 1113 }), 1114 } 1115 }