12488 12488 | let is_complement = ref_val < 0;
|
12489 12489 | let node = &NODES[(ref_val.unsigned_abs() as usize) - 1];
|
12490 12490 | let condition_result = match node.condition_index {
|
12491 12491 | 0 => region.is_some(),
|
12492 12492 | 1 => (accelerate) == (&true),
|
12493 12493 | 2 => (use_fips) == (&true),
|
12494 12494 | 3 => (use_dual_stack) == (&true),
|
12495 12495 | 4 => endpoint.is_some(),
|
12496 12496 | 5 => bucket.is_some(),
|
12497 12497 | 6 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12498 - | let partition_result = &mut context.partition_result;
|
12499 - | let access_point_suffix = &mut context.access_point_suffix;
|
12500 - | let region_prefix = &mut context.region_prefix;
|
12501 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12502 - | let hardware_type = &mut context.hardware_type;
|
12503 - | let s3_e_ds = &mut context.s3_e_ds;
|
12504 - | let s3_e_fips = &mut context.s3_e_fips;
|
12505 - | let s3_e_auth = &mut context.s3_e_auth;
|
12506 - | let url = &mut context.url;
|
12507 - | let bucket_arn = &mut context.bucket_arn;
|
12508 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12509 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12510 - | let arn_type = &mut context.arn_type;
|
12511 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12512 - | let bucket_partition = &mut context.bucket_partition;
|
12513 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12514 - | let outpost_type = &mut context.outpost_type;
|
12515 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12516 12498 | let partition_resolver = &self.partition_resolver;
|
12517 12499 | (crate::endpoint_lib::coalesce::coalesce!(
|
12518 12500 | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
12519 12501 | if let Some(param) = bucket { param } else { return false },
|
12520 12502 | 0,
|
12521 12503 | 6,
|
12522 12504 | true,
|
12523 12505 | _diagnostic_collector
|
12524 12506 | ) {
|
12525 12507 | inner
|
12526 12508 | } else {
|
12527 12509 | return false;
|
12528 12510 | },
|
12529 12511 | "".to_string()
|
12530 12512 | )) == ("--x-s3")
|
12531 12513 | })(&mut _diagnostic_collector),
|
12532 12514 | 7 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12533 - | let partition_result = &mut context.partition_result;
|
12534 - | let access_point_suffix = &mut context.access_point_suffix;
|
12535 - | let region_prefix = &mut context.region_prefix;
|
12536 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12537 - | let hardware_type = &mut context.hardware_type;
|
12538 - | let s3_e_ds = &mut context.s3_e_ds;
|
12539 - | let s3_e_fips = &mut context.s3_e_fips;
|
12540 - | let s3_e_auth = &mut context.s3_e_auth;
|
12541 - | let url = &mut context.url;
|
12542 - | let bucket_arn = &mut context.bucket_arn;
|
12543 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12544 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12545 - | let arn_type = &mut context.arn_type;
|
12546 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12547 - | let bucket_partition = &mut context.bucket_partition;
|
12548 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12549 - | let outpost_type = &mut context.outpost_type;
|
12550 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12551 12515 | let partition_resolver = &self.partition_resolver;
|
12552 12516 | (crate::endpoint_lib::coalesce::coalesce!(
|
12553 12517 | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
12554 12518 | if let Some(param) = bucket { param } else { return false },
|
12555 12519 | 0,
|
12556 12520 | 7,
|
12557 12521 | true,
|
12558 12522 | _diagnostic_collector
|
12559 12523 | ) {
|
12560 12524 | inner
|
12561 12525 | } else {
|
12562 12526 | return false;
|
12563 12527 | },
|
12564 12528 | "".to_string()
|
12565 12529 | )) == ("--xa-s3")
|
12566 12530 | })(&mut _diagnostic_collector),
|
12567 12531 | 8 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12568 12532 | let partition_result = &mut context.partition_result;
|
12569 - | let access_point_suffix = &mut context.access_point_suffix;
|
12570 - | let region_prefix = &mut context.region_prefix;
|
12571 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12572 - | let hardware_type = &mut context.hardware_type;
|
12573 - | let s3_e_ds = &mut context.s3_e_ds;
|
12574 - | let s3_e_fips = &mut context.s3_e_fips;
|
12575 - | let s3_e_auth = &mut context.s3_e_auth;
|
12576 - | let url = &mut context.url;
|
12577 - | let bucket_arn = &mut context.bucket_arn;
|
12578 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12579 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12580 - | let arn_type = &mut context.arn_type;
|
12581 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12582 - | let bucket_partition = &mut context.bucket_partition;
|
12583 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12584 - | let outpost_type = &mut context.outpost_type;
|
12585 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12586 12533 | let partition_resolver = &self.partition_resolver;
|
12587 12534 | {
|
12588 12535 | *partition_result = partition_resolver
|
12589 12536 | .resolve_partition(if let Some(param) = region { param } else { return false }, _diagnostic_collector)
|
12590 12537 | .map(|inner| inner.into());
|
12591 12538 | partition_result.is_some()
|
12592 12539 | }
|
12593 12540 | })(&mut _diagnostic_collector),
|
12594 12541 | 9 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12595 - | let partition_result = &mut context.partition_result;
|
12596 12542 | let access_point_suffix = &mut context.access_point_suffix;
|
12597 - | let region_prefix = &mut context.region_prefix;
|
12598 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12599 - | let hardware_type = &mut context.hardware_type;
|
12600 - | let s3_e_ds = &mut context.s3_e_ds;
|
12601 - | let s3_e_fips = &mut context.s3_e_fips;
|
12602 - | let s3_e_auth = &mut context.s3_e_auth;
|
12603 - | let url = &mut context.url;
|
12604 - | let bucket_arn = &mut context.bucket_arn;
|
12605 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12606 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12607 - | let arn_type = &mut context.arn_type;
|
12608 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12609 - | let bucket_partition = &mut context.bucket_partition;
|
12610 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12611 - | let outpost_type = &mut context.outpost_type;
|
12612 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12613 12543 | let partition_resolver = &self.partition_resolver;
|
12614 12544 | {
|
12615 12545 | *access_point_suffix = crate::endpoint_lib::substring::substring(
|
12616 12546 | if let Some(param) = bucket { param } else { return false },
|
12617 12547 | 0,
|
12618 12548 | 7,
|
12619 12549 | true,
|
12620 12550 | _diagnostic_collector,
|
12621 12551 | )
|
12622 12552 | .map(|inner| inner.into());
|
12623 12553 | access_point_suffix.is_some()
|
12624 12554 | }
|
12625 12555 | })(&mut _diagnostic_collector),
|
12626 12556 | 10 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12627 - | let partition_result = &mut context.partition_result;
|
12628 - | let access_point_suffix = &mut context.access_point_suffix;
|
12629 - | let region_prefix = &mut context.region_prefix;
|
12630 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12631 - | let hardware_type = &mut context.hardware_type;
|
12632 - | let s3_e_ds = &mut context.s3_e_ds;
|
12633 - | let s3_e_fips = &mut context.s3_e_fips;
|
12634 - | let s3_e_auth = &mut context.s3_e_auth;
|
12635 - | let url = &mut context.url;
|
12636 - | let bucket_arn = &mut context.bucket_arn;
|
12637 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12638 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12639 - | let arn_type = &mut context.arn_type;
|
12640 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12641 - | let bucket_partition = &mut context.bucket_partition;
|
12642 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12643 - | let outpost_type = &mut context.outpost_type;
|
12644 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12557 + | let access_point_suffix = &context.access_point_suffix;
|
12645 12558 | let partition_resolver = &self.partition_resolver;
|
12646 - | (access_point_suffix) == &mut Some(("--op-s3".into()))
|
12559 + | (access_point_suffix) == &mut Some(("--op-s3".to_string().into()))
|
12647 12560 | })(&mut _diagnostic_collector),
|
12648 12561 | 11 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12649 - | let partition_result = &mut context.partition_result;
|
12650 - | let access_point_suffix = &mut context.access_point_suffix;
|
12651 12562 | let region_prefix = &mut context.region_prefix;
|
12652 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12653 - | let hardware_type = &mut context.hardware_type;
|
12654 - | let s3_e_ds = &mut context.s3_e_ds;
|
12655 - | let s3_e_fips = &mut context.s3_e_fips;
|
12656 - | let s3_e_auth = &mut context.s3_e_auth;
|
12657 - | let url = &mut context.url;
|
12658 - | let bucket_arn = &mut context.bucket_arn;
|
12659 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12660 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12661 - | let arn_type = &mut context.arn_type;
|
12662 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12663 - | let bucket_partition = &mut context.bucket_partition;
|
12664 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12665 - | let outpost_type = &mut context.outpost_type;
|
12666 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12667 12563 | let partition_resolver = &self.partition_resolver;
|
12668 12564 | {
|
12669 12565 | *region_prefix = crate::endpoint_lib::substring::substring(
|
12670 12566 | if let Some(param) = bucket { param } else { return false },
|
12671 12567 | 8,
|
12672 12568 | 12,
|
12673 12569 | true,
|
12674 12570 | _diagnostic_collector,
|
12675 12571 | )
|
12676 12572 | .map(|inner| inner.into());
|
12677 12573 | region_prefix.is_some()
|
12678 12574 | }
|
12679 12575 | })(&mut _diagnostic_collector),
|
12680 12576 | 12 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12681 - | let partition_result = &mut context.partition_result;
|
12682 - | let access_point_suffix = &mut context.access_point_suffix;
|
12683 - | let region_prefix = &mut context.region_prefix;
|
12684 12577 | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12685 - | let hardware_type = &mut context.hardware_type;
|
12686 - | let s3_e_ds = &mut context.s3_e_ds;
|
12687 - | let s3_e_fips = &mut context.s3_e_fips;
|
12688 - | let s3_e_auth = &mut context.s3_e_auth;
|
12689 - | let url = &mut context.url;
|
12690 - | let bucket_arn = &mut context.bucket_arn;
|
12691 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12692 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12693 - | let arn_type = &mut context.arn_type;
|
12694 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12695 - | let bucket_partition = &mut context.bucket_partition;
|
12696 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12697 - | let outpost_type = &mut context.outpost_type;
|
12698 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12699 12578 | let partition_resolver = &self.partition_resolver;
|
12700 12579 | {
|
12701 12580 | *outpost_id_ssa_2 = crate::endpoint_lib::substring::substring(
|
12702 12581 | if let Some(param) = bucket { param } else { return false },
|
12703 12582 | 32,
|
12704 12583 | 49,
|
12705 12584 | true,
|
12706 12585 | _diagnostic_collector,
|
12707 12586 | )
|
12708 12587 | .map(|inner| inner.into());
|
12709 12588 | outpost_id_ssa_2.is_some()
|
12710 12589 | }
|
12711 12590 | })(&mut _diagnostic_collector),
|
12712 12591 | 13 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12713 - | let partition_result = &mut context.partition_result;
|
12714 - | let access_point_suffix = &mut context.access_point_suffix;
|
12715 - | let region_prefix = &mut context.region_prefix;
|
12716 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12717 12592 | let hardware_type = &mut context.hardware_type;
|
12718 - | let s3_e_ds = &mut context.s3_e_ds;
|
12719 - | let s3_e_fips = &mut context.s3_e_fips;
|
12720 - | let s3_e_auth = &mut context.s3_e_auth;
|
12721 - | let url = &mut context.url;
|
12722 - | let bucket_arn = &mut context.bucket_arn;
|
12723 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12724 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12725 - | let arn_type = &mut context.arn_type;
|
12726 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12727 - | let bucket_partition = &mut context.bucket_partition;
|
12728 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12729 - | let outpost_type = &mut context.outpost_type;
|
12730 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12731 12593 | let partition_resolver = &self.partition_resolver;
|
12732 12594 | {
|
12733 12595 | *hardware_type = crate::endpoint_lib::substring::substring(
|
12734 12596 | if let Some(param) = bucket { param } else { return false },
|
12735 12597 | 49,
|
12736 12598 | 50,
|
12737 12599 | true,
|
12738 12600 | _diagnostic_collector,
|
12739 12601 | )
|
12740 12602 | .map(|inner| inner.into());
|
12741 12603 | hardware_type.is_some()
|
12742 12604 | }
|
12743 12605 | })(&mut _diagnostic_collector),
|
12744 12606 | 14 => (force_path_style) == (&true),
|
12745 12607 | 15 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12746 - | let partition_result = &mut context.partition_result;
|
12747 - | let access_point_suffix = &mut context.access_point_suffix;
|
12748 - | let region_prefix = &mut context.region_prefix;
|
12749 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12750 - | let hardware_type = &mut context.hardware_type;
|
12751 - | let s3_e_ds = &mut context.s3_e_ds;
|
12752 - | let s3_e_fips = &mut context.s3_e_fips;
|
12753 - | let s3_e_auth = &mut context.s3_e_auth;
|
12754 - | let url = &mut context.url;
|
12755 - | let bucket_arn = &mut context.bucket_arn;
|
12756 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12757 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12758 - | let arn_type = &mut context.arn_type;
|
12759 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12760 - | let bucket_partition = &mut context.bucket_partition;
|
12761 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12762 - | let outpost_type = &mut context.outpost_type;
|
12763 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12608 + | let partition_result = &context.partition_result;
|
12764 12609 | let partition_resolver = &self.partition_resolver;
|
12765 12610 | (if let Some(inner) = partition_result {
|
12766 12611 | inner.name()
|
12767 12612 | } else {
|
12768 12613 | return false;
|
12769 12614 | }) == ("aws-cn")
|
12770 12615 | })(&mut _diagnostic_collector),
|
12771 12616 | 16 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12772 - | let partition_result = &mut context.partition_result;
|
12773 - | let access_point_suffix = &mut context.access_point_suffix;
|
12774 - | let region_prefix = &mut context.region_prefix;
|
12775 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12776 - | let hardware_type = &mut context.hardware_type;
|
12777 12617 | let s3_e_ds = &mut context.s3_e_ds;
|
12778 - | let s3_e_fips = &mut context.s3_e_fips;
|
12779 - | let s3_e_auth = &mut context.s3_e_auth;
|
12780 - | let url = &mut context.url;
|
12781 - | let bucket_arn = &mut context.bucket_arn;
|
12782 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12783 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12784 - | let arn_type = &mut context.arn_type;
|
12785 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12786 - | let bucket_partition = &mut context.bucket_partition;
|
12787 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12788 - | let outpost_type = &mut context.outpost_type;
|
12789 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12790 12618 | let partition_resolver = &self.partition_resolver;
|
12791 12619 | {
|
12792 12620 | *s3_e_ds = Some(crate::endpoint_lib::ite::ite!(use_dual_stack, ".dualstack".to_string(), "".to_string()).into());
|
12793 12621 | true
|
12794 12622 | }
|
12795 12623 | })(&mut _diagnostic_collector),
|
12796 12624 | 17 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12797 - | let partition_result = &mut context.partition_result;
|
12798 - | let access_point_suffix = &mut context.access_point_suffix;
|
12799 - | let region_prefix = &mut context.region_prefix;
|
12800 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12801 - | let hardware_type = &mut context.hardware_type;
|
12802 - | let s3_e_ds = &mut context.s3_e_ds;
|
12803 - | let s3_e_fips = &mut context.s3_e_fips;
|
12804 - | let s3_e_auth = &mut context.s3_e_auth;
|
12805 - | let url = &mut context.url;
|
12806 - | let bucket_arn = &mut context.bucket_arn;
|
12807 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12808 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12809 - | let arn_type = &mut context.arn_type;
|
12810 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12811 - | let bucket_partition = &mut context.bucket_partition;
|
12812 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12813 - | let outpost_type = &mut context.outpost_type;
|
12814 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12625 + | let outpost_id_ssa_2 = &context.outpost_id_ssa_2;
|
12815 12626 | let partition_resolver = &self.partition_resolver;
|
12816 12627 | crate::endpoint_lib::host::is_valid_host_label(
|
12817 12628 | if let Some(param) = outpost_id_ssa_2 { param } else { return false },
|
12818 12629 | false,
|
12819 12630 | _diagnostic_collector,
|
12820 12631 | )
|
12821 12632 | })(&mut _diagnostic_collector),
|
12822 12633 | 18 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12823 - | let partition_result = &mut context.partition_result;
|
12824 - | let access_point_suffix = &mut context.access_point_suffix;
|
12825 - | let region_prefix = &mut context.region_prefix;
|
12826 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12827 - | let hardware_type = &mut context.hardware_type;
|
12828 - | let s3_e_ds = &mut context.s3_e_ds;
|
12829 12634 | let s3_e_fips = &mut context.s3_e_fips;
|
12830 - | let s3_e_auth = &mut context.s3_e_auth;
|
12831 - | let url = &mut context.url;
|
12832 - | let bucket_arn = &mut context.bucket_arn;
|
12833 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12834 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12835 - | let arn_type = &mut context.arn_type;
|
12836 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12837 - | let bucket_partition = &mut context.bucket_partition;
|
12838 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12839 - | let outpost_type = &mut context.outpost_type;
|
12840 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12841 12635 | let partition_resolver = &self.partition_resolver;
|
12842 12636 | {
|
12843 12637 | *s3_e_fips = Some(crate::endpoint_lib::ite::ite!(use_fips, "-fips".to_string(), "".to_string()).into());
|
12844 12638 | true
|
12845 12639 | }
|
12846 12640 | })(&mut _diagnostic_collector),
|
12847 12641 | 19 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12848 - | let partition_result = &mut context.partition_result;
|
12849 - | let access_point_suffix = &mut context.access_point_suffix;
|
12850 - | let region_prefix = &mut context.region_prefix;
|
12851 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12852 - | let hardware_type = &mut context.hardware_type;
|
12853 - | let s3_e_ds = &mut context.s3_e_ds;
|
12854 - | let s3_e_fips = &mut context.s3_e_fips;
|
12855 12642 | let s3_e_auth = &mut context.s3_e_auth;
|
12856 - | let url = &mut context.url;
|
12857 - | let bucket_arn = &mut context.bucket_arn;
|
12858 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12859 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12860 - | let arn_type = &mut context.arn_type;
|
12861 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12862 - | let bucket_partition = &mut context.bucket_partition;
|
12863 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12864 - | let outpost_type = &mut context.outpost_type;
|
12865 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12866 12643 | let partition_resolver = &self.partition_resolver;
|
12867 12644 | {
|
12868 12645 | *s3_e_auth = Some(
|
12869 12646 | crate::endpoint_lib::ite::ite!(
|
12870 12647 | crate::endpoint_lib::coalesce::coalesce!(disable_s3_express_session_auth.clone(), false),
|
12871 12648 | "sigv4".to_string(),
|
12872 12649 | "sigv4-s3express".to_string()
|
12873 12650 | )
|
12874 12651 | .into(),
|
12875 12652 | );
|
12876 12653 | true
|
12877 12654 | }
|
12878 12655 | })(&mut _diagnostic_collector),
|
12879 12656 | 20 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12880 - | let partition_result = &mut context.partition_result;
|
12881 - | let access_point_suffix = &mut context.access_point_suffix;
|
12882 - | let region_prefix = &mut context.region_prefix;
|
12883 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12884 - | let hardware_type = &mut context.hardware_type;
|
12885 - | let s3_e_ds = &mut context.s3_e_ds;
|
12886 - | let s3_e_fips = &mut context.s3_e_fips;
|
12887 - | let s3_e_auth = &mut context.s3_e_auth;
|
12888 - | let url = &mut context.url;
|
12889 - | let bucket_arn = &mut context.bucket_arn;
|
12890 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12891 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12892 - | let arn_type = &mut context.arn_type;
|
12893 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12894 - | let bucket_partition = &mut context.bucket_partition;
|
12895 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12896 - | let outpost_type = &mut context.outpost_type;
|
12897 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12898 12657 | let partition_resolver = &self.partition_resolver;
|
12899 12658 | crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(
|
12900 12659 | if let Some(param) = bucket { param } else { return false },
|
12901 12660 | false,
|
12902 12661 | _diagnostic_collector,
|
12903 12662 | )
|
12904 12663 | })(&mut _diagnostic_collector),
|
12905 12664 | 21 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12906 - | let partition_result = &mut context.partition_result;
|
12907 - | let access_point_suffix = &mut context.access_point_suffix;
|
12908 - | let region_prefix = &mut context.region_prefix;
|
12909 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12910 - | let hardware_type = &mut context.hardware_type;
|
12911 - | let s3_e_ds = &mut context.s3_e_ds;
|
12912 - | let s3_e_fips = &mut context.s3_e_fips;
|
12913 - | let s3_e_auth = &mut context.s3_e_auth;
|
12914 12665 | let url = &mut context.url;
|
12915 - | let bucket_arn = &mut context.bucket_arn;
|
12916 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12917 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12918 - | let arn_type = &mut context.arn_type;
|
12919 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12920 - | let bucket_partition = &mut context.bucket_partition;
|
12921 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12922 - | let outpost_type = &mut context.outpost_type;
|
12923 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12924 12666 | let partition_resolver = &self.partition_resolver;
|
12925 12667 | {
|
12926 12668 | *url = crate::endpoint_lib::parse_url::parse_url(
|
12927 12669 | if let Some(param) = endpoint { param } else { return false },
|
12928 12670 | _diagnostic_collector,
|
12929 12671 | )
|
12930 12672 | .map(|inner| inner.into());
|
12931 12673 | url.is_some()
|
12932 12674 | }
|
12933 12675 | })(&mut _diagnostic_collector),
|
12934 12676 | 22 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12935 - | let partition_result = &mut context.partition_result;
|
12936 - | let access_point_suffix = &mut context.access_point_suffix;
|
12937 - | let region_prefix = &mut context.region_prefix;
|
12938 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12939 - | let hardware_type = &mut context.hardware_type;
|
12940 - | let s3_e_ds = &mut context.s3_e_ds;
|
12941 - | let s3_e_fips = &mut context.s3_e_fips;
|
12942 - | let s3_e_auth = &mut context.s3_e_auth;
|
12943 - | let url = &mut context.url;
|
12944 - | let bucket_arn = &mut context.bucket_arn;
|
12945 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12946 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12947 - | let arn_type = &mut context.arn_type;
|
12948 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12949 - | let bucket_partition = &mut context.bucket_partition;
|
12950 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12951 - | let outpost_type = &mut context.outpost_type;
|
12952 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12953 12677 | let partition_resolver = &self.partition_resolver;
|
12954 12678 | (crate::endpoint_lib::coalesce::coalesce!(use_s3_express_control_endpoint.clone(), false)) == (true)
|
12955 12679 | })(&mut _diagnostic_collector),
|
12956 12680 | 23 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12957 - | let partition_result = &mut context.partition_result;
|
12958 - | let access_point_suffix = &mut context.access_point_suffix;
|
12959 - | let region_prefix = &mut context.region_prefix;
|
12960 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12961 - | let hardware_type = &mut context.hardware_type;
|
12962 - | let s3_e_ds = &mut context.s3_e_ds;
|
12963 - | let s3_e_fips = &mut context.s3_e_fips;
|
12964 - | let s3_e_auth = &mut context.s3_e_auth;
|
12965 - | let url = &mut context.url;
|
12966 - | let bucket_arn = &mut context.bucket_arn;
|
12967 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12968 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12969 - | let arn_type = &mut context.arn_type;
|
12970 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12971 - | let bucket_partition = &mut context.bucket_partition;
|
12972 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12973 - | let outpost_type = &mut context.outpost_type;
|
12974 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12975 12681 | let partition_resolver = &self.partition_resolver;
|
12976 12682 | crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(
|
12977 12683 | if let Some(param) = bucket { param } else { return false },
|
12978 12684 | true,
|
12979 12685 | _diagnostic_collector,
|
12980 12686 | )
|
12981 12687 | })(&mut _diagnostic_collector),
|
12982 12688 | 24 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
12983 - | let partition_result = &mut context.partition_result;
|
12984 - | let access_point_suffix = &mut context.access_point_suffix;
|
12985 - | let region_prefix = &mut context.region_prefix;
|
12986 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12987 - | let hardware_type = &mut context.hardware_type;
|
12988 - | let s3_e_ds = &mut context.s3_e_ds;
|
12989 - | let s3_e_fips = &mut context.s3_e_fips;
|
12990 - | let s3_e_auth = &mut context.s3_e_auth;
|
12991 - | let url = &mut context.url;
|
12992 - | let bucket_arn = &mut context.bucket_arn;
|
12993 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12994 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12995 - | let arn_type = &mut context.arn_type;
|
12996 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12997 - | let bucket_partition = &mut context.bucket_partition;
|
12998 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12999 - | let outpost_type = &mut context.outpost_type;
|
13000 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12689 + | let url = &context.url;
|
13001 12690 | let partition_resolver = &self.partition_resolver;
|
13002 12691 | (if let Some(inner) = url { inner.scheme() } else { return false }) == ("http")
|
13003 12692 | })(&mut _diagnostic_collector),
|
13004 12693 | 25 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13005 - | let partition_result = &mut context.partition_result;
|
13006 - | let access_point_suffix = &mut context.access_point_suffix;
|
13007 - | let region_prefix = &mut context.region_prefix;
|
13008 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13009 - | let hardware_type = &mut context.hardware_type;
|
13010 - | let s3_e_ds = &mut context.s3_e_ds;
|
13011 - | let s3_e_fips = &mut context.s3_e_fips;
|
13012 - | let s3_e_auth = &mut context.s3_e_auth;
|
13013 - | let url = &mut context.url;
|
13014 - | let bucket_arn = &mut context.bucket_arn;
|
13015 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13016 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13017 - | let arn_type = &mut context.arn_type;
|
13018 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13019 - | let bucket_partition = &mut context.bucket_partition;
|
13020 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13021 - | let outpost_type = &mut context.outpost_type;
|
13022 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13023 12694 | let partition_resolver = &self.partition_resolver;
|
13024 12695 | crate::endpoint_lib::host::is_valid_host_label(
|
13025 12696 | if let Some(param) = region { param } else { return false },
|
13026 12697 | false,
|
13027 12698 | _diagnostic_collector,
|
13028 12699 | )
|
13029 12700 | })(&mut _diagnostic_collector),
|
13030 12701 | 26 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13031 - | let partition_result = &mut context.partition_result;
|
13032 - | let access_point_suffix = &mut context.access_point_suffix;
|
13033 - | let region_prefix = &mut context.region_prefix;
|
13034 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13035 - | let hardware_type = &mut context.hardware_type;
|
13036 - | let s3_e_ds = &mut context.s3_e_ds;
|
13037 - | let s3_e_fips = &mut context.s3_e_fips;
|
13038 - | let s3_e_auth = &mut context.s3_e_auth;
|
13039 - | let url = &mut context.url;
|
13040 12702 | let bucket_arn = &mut context.bucket_arn;
|
13041 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13042 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13043 - | let arn_type = &mut context.arn_type;
|
13044 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13045 - | let bucket_partition = &mut context.bucket_partition;
|
13046 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13047 - | let outpost_type = &mut context.outpost_type;
|
13048 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13049 12703 | let partition_resolver = &self.partition_resolver;
|
13050 12704 | {
|
13051 12705 | *bucket_arn = crate::endpoint_lib::arn::parse_arn(
|
13052 12706 | if let Some(param) = bucket { param } else { return false },
|
13053 12707 | _diagnostic_collector,
|
13054 12708 | )
|
13055 12709 | .map(|inner| inner.into());
|
13056 12710 | bucket_arn.is_some()
|
13057 12711 | }
|
13058 12712 | })(&mut _diagnostic_collector),
|
13059 12713 | 27 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13060 - | let partition_result = &mut context.partition_result;
|
13061 - | let access_point_suffix = &mut context.access_point_suffix;
|
13062 - | let region_prefix = &mut context.region_prefix;
|
13063 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13064 - | let hardware_type = &mut context.hardware_type;
|
13065 - | let s3_e_ds = &mut context.s3_e_ds;
|
13066 - | let s3_e_fips = &mut context.s3_e_fips;
|
13067 - | let s3_e_auth = &mut context.s3_e_auth;
|
13068 - | let url = &mut context.url;
|
13069 - | let bucket_arn = &mut context.bucket_arn;
|
13070 12714 | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13071 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13072 - | let arn_type = &mut context.arn_type;
|
13073 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13074 - | let bucket_partition = &mut context.bucket_partition;
|
13075 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13076 - | let outpost_type = &mut context.outpost_type;
|
13077 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13078 12715 | let partition_resolver = &self.partition_resolver;
|
13079 12716 | {
|
13080 12717 | *s3express_availability_zone_id = crate::endpoint_lib::split::split(
|
13081 12718 | if let Some(param) = bucket { param } else { return false },
|
13082 12719 | "--",
|
13083 12720 | 0,
|
13084 12721 | _diagnostic_collector,
|
13085 12722 | )
|
13086 12723 | .iter()
|
13087 12724 | .nth_back(1)
|
13088 12725 | .cloned()
|
13089 12726 | .map(|inner| inner.into());
|
13090 12727 | s3express_availability_zone_id.is_some()
|
13091 12728 | }
|
13092 12729 | })(&mut _diagnostic_collector),
|
13093 12730 | 28 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13094 - | let partition_result = &mut context.partition_result;
|
13095 - | let access_point_suffix = &mut context.access_point_suffix;
|
13096 - | let region_prefix = &mut context.region_prefix;
|
13097 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13098 - | let hardware_type = &mut context.hardware_type;
|
13099 - | let s3_e_ds = &mut context.s3_e_ds;
|
13100 - | let s3_e_fips = &mut context.s3_e_fips;
|
13101 - | let s3_e_auth = &mut context.s3_e_auth;
|
13102 - | let url = &mut context.url;
|
13103 - | let bucket_arn = &mut context.bucket_arn;
|
13104 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13105 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13106 - | let arn_type = &mut context.arn_type;
|
13107 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13108 - | let bucket_partition = &mut context.bucket_partition;
|
13109 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13110 - | let outpost_type = &mut context.outpost_type;
|
13111 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13112 12731 | let partition_resolver = &self.partition_resolver;
|
13113 12732 | (crate::endpoint_lib::coalesce::coalesce!(
|
13114 12733 | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
13115 12734 | if let Some(param) = bucket { param } else { return false },
|
13116 12735 | 0,
|
13117 12736 | 4,
|
13118 12737 | false,
|
13119 12738 | _diagnostic_collector
|
13120 12739 | ) {
|
13121 12740 | inner
|
13122 12741 | } else {
|
13123 12742 | return false;
|
13124 12743 | },
|
13125 12744 | "".to_string()
|
13126 12745 | )) == ("arn:")
|
13127 12746 | })(&mut _diagnostic_collector),
|
13128 12747 | 29 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13129 - | let partition_result = &mut context.partition_result;
|
13130 - | let access_point_suffix = &mut context.access_point_suffix;
|
13131 - | let region_prefix = &mut context.region_prefix;
|
13132 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13133 - | let hardware_type = &mut context.hardware_type;
|
13134 - | let s3_e_ds = &mut context.s3_e_ds;
|
13135 - | let s3_e_fips = &mut context.s3_e_fips;
|
13136 - | let s3_e_auth = &mut context.s3_e_auth;
|
13137 - | let url = &mut context.url;
|
13138 - | let bucket_arn = &mut context.bucket_arn;
|
13139 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13140 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13141 - | let arn_type = &mut context.arn_type;
|
13142 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13143 - | let bucket_partition = &mut context.bucket_partition;
|
13144 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13145 - | let outpost_type = &mut context.outpost_type;
|
13146 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13147 12748 | let partition_resolver = &self.partition_resolver;
|
13148 12749 | (crate::endpoint_lib::coalesce::coalesce!(
|
13149 12750 | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
13150 12751 | if let Some(param) = bucket { param } else { return false },
|
13151 12752 | 16,
|
13152 12753 | 18,
|
13153 12754 | true,
|
13154 12755 | _diagnostic_collector
|
13155 12756 | ) {
|
13156 12757 | inner
|
13157 12758 | } else {
|
13158 12759 | return false;
|
13159 12760 | },
|
13160 12761 | "".to_string()
|
13161 12762 | )) == ("--")
|
13162 12763 | })(&mut _diagnostic_collector),
|
13163 12764 | 30 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13164 - | let partition_result = &mut context.partition_result;
|
13165 - | let access_point_suffix = &mut context.access_point_suffix;
|
13166 - | let region_prefix = &mut context.region_prefix;
|
13167 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13168 - | let hardware_type = &mut context.hardware_type;
|
13169 - | let s3_e_ds = &mut context.s3_e_ds;
|
13170 - | let s3_e_fips = &mut context.s3_e_fips;
|
13171 - | let s3_e_auth = &mut context.s3_e_auth;
|
13172 - | let url = &mut context.url;
|
13173 - | let bucket_arn = &mut context.bucket_arn;
|
13174 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13175 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13176 - | let arn_type = &mut context.arn_type;
|
13177 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13178 - | let bucket_partition = &mut context.bucket_partition;
|
13179 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13180 - | let outpost_type = &mut context.outpost_type;
|
13181 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12765 + | let url = &context.url;
|
13182 12766 | let partition_resolver = &self.partition_resolver;
|
13183 12767 | (if let Some(inner) = url { inner.is_ip() } else { return false }) == (true)
|
13184 12768 | })(&mut _diagnostic_collector),
|
13185 12769 | 31 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13186 - | let partition_result = &mut context.partition_result;
|
13187 - | let access_point_suffix = &mut context.access_point_suffix;
|
13188 - | let region_prefix = &mut context.region_prefix;
|
13189 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13190 - | let hardware_type = &mut context.hardware_type;
|
13191 - | let s3_e_ds = &mut context.s3_e_ds;
|
13192 - | let s3_e_fips = &mut context.s3_e_fips;
|
13193 - | let s3_e_auth = &mut context.s3_e_auth;
|
13194 - | let url = &mut context.url;
|
13195 - | let bucket_arn = &mut context.bucket_arn;
|
13196 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13197 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13198 - | let arn_type = &mut context.arn_type;
|
13199 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13200 - | let bucket_partition = &mut context.bucket_partition;
|
13201 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13202 - | let outpost_type = &mut context.outpost_type;
|
13203 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13204 12770 | let partition_resolver = &self.partition_resolver;
|
13205 12771 | (crate::endpoint_lib::coalesce::coalesce!(
|
13206 12772 | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
13207 12773 | if let Some(param) = bucket { param } else { return false },
|
13208 12774 | 21,
|
13209 12775 | 23,
|
13210 12776 | true,
|
13211 12777 | _diagnostic_collector
|
13212 12778 | ) {
|
13213 12779 | inner
|
13214 12780 | } else {
|
13215 12781 | return false;
|
13216 12782 | },
|
13217 12783 | "".to_string()
|
13218 12784 | )) == ("--")
|
13219 12785 | })(&mut _diagnostic_collector),
|
13220 12786 | 32 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13221 - | let partition_result = &mut context.partition_result;
|
13222 - | let access_point_suffix = &mut context.access_point_suffix;
|
13223 - | let region_prefix = &mut context.region_prefix;
|
13224 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13225 - | let hardware_type = &mut context.hardware_type;
|
13226 - | let s3_e_ds = &mut context.s3_e_ds;
|
13227 - | let s3_e_fips = &mut context.s3_e_fips;
|
13228 - | let s3_e_auth = &mut context.s3_e_auth;
|
13229 - | let url = &mut context.url;
|
13230 - | let bucket_arn = &mut context.bucket_arn;
|
13231 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13232 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13233 - | let arn_type = &mut context.arn_type;
|
13234 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13235 - | let bucket_partition = &mut context.bucket_partition;
|
13236 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13237 - | let outpost_type = &mut context.outpost_type;
|
13238 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13239 12787 | let partition_resolver = &self.partition_resolver;
|
13240 12788 | (crate::endpoint_lib::coalesce::coalesce!(
|
13241 12789 | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
13242 12790 | if let Some(param) = bucket { param } else { return false },
|
13243 12791 | 27,
|
13244 12792 | 29,
|
13245 12793 | true,
|
13246 12794 | _diagnostic_collector
|
13247 12795 | ) {
|
13248 12796 | inner
|
13249 12797 | } else {
|
13250 12798 | return false;
|
13251 12799 | },
|
13252 12800 | "".to_string()
|
13253 12801 | )) == ("--")
|
13254 12802 | })(&mut _diagnostic_collector),
|
13255 12803 | 33 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13256 - | let partition_result = &mut context.partition_result;
|
13257 - | let access_point_suffix = &mut context.access_point_suffix;
|
13258 - | let region_prefix = &mut context.region_prefix;
|
13259 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13260 - | let hardware_type = &mut context.hardware_type;
|
13261 - | let s3_e_ds = &mut context.s3_e_ds;
|
13262 - | let s3_e_fips = &mut context.s3_e_fips;
|
13263 - | let s3_e_auth = &mut context.s3_e_auth;
|
13264 - | let url = &mut context.url;
|
13265 - | let bucket_arn = &mut context.bucket_arn;
|
13266 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13267 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13268 - | let arn_type = &mut context.arn_type;
|
13269 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13270 - | let bucket_partition = &mut context.bucket_partition;
|
13271 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13272 - | let outpost_type = &mut context.outpost_type;
|
13273 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12804 + | let region_prefix = &context.region_prefix;
|
13274 12805 | let partition_resolver = &self.partition_resolver;
|
13275 - | (region_prefix) == &mut Some(("beta".into()))
|
12806 + | (region_prefix) == &mut Some(("beta".to_string().into()))
|
13276 12807 | })(&mut _diagnostic_collector),
|
13277 12808 | 34 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13278 - | let partition_result = &mut context.partition_result;
|
13279 - | let access_point_suffix = &mut context.access_point_suffix;
|
13280 - | let region_prefix = &mut context.region_prefix;
|
13281 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13282 - | let hardware_type = &mut context.hardware_type;
|
13283 - | let s3_e_ds = &mut context.s3_e_ds;
|
13284 - | let s3_e_fips = &mut context.s3_e_fips;
|
13285 - | let s3_e_auth = &mut context.s3_e_auth;
|
13286 - | let url = &mut context.url;
|
13287 - | let bucket_arn = &mut context.bucket_arn;
|
13288 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13289 12809 | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13290 - | let arn_type = &mut context.arn_type;
|
13291 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13292 - | let bucket_partition = &mut context.bucket_partition;
|
13293 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13294 - | let outpost_type = &mut context.outpost_type;
|
13295 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13296 12810 | let partition_resolver = &self.partition_resolver;
|
13297 12811 | {
|
13298 12812 | *uri_encoded_bucket = Some(
|
13299 12813 | crate::endpoint_lib::uri_encode::uri_encode(
|
13300 12814 | if let Some(param) = bucket { param } else { return false },
|
13301 12815 | _diagnostic_collector,
|
13302 12816 | )
|
13303 12817 | .into(),
|
13304 12818 | );
|
13305 12819 | true
|
13306 12820 | }
|
13307 12821 | })(&mut _diagnostic_collector),
|
13308 12822 | 35 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13309 - | let partition_result = &mut context.partition_result;
|
13310 - | let access_point_suffix = &mut context.access_point_suffix;
|
13311 - | let region_prefix = &mut context.region_prefix;
|
13312 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13313 - | let hardware_type = &mut context.hardware_type;
|
13314 - | let s3_e_ds = &mut context.s3_e_ds;
|
13315 - | let s3_e_fips = &mut context.s3_e_fips;
|
13316 - | let s3_e_auth = &mut context.s3_e_auth;
|
13317 - | let url = &mut context.url;
|
13318 - | let bucket_arn = &mut context.bucket_arn;
|
13319 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13320 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13321 - | let arn_type = &mut context.arn_type;
|
13322 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13323 - | let bucket_partition = &mut context.bucket_partition;
|
13324 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13325 - | let outpost_type = &mut context.outpost_type;
|
13326 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13327 12823 | let partition_resolver = &self.partition_resolver;
|
13328 12824 | crate::endpoint_lib::host::is_valid_host_label(
|
13329 12825 | if let Some(param) = region { param } else { return false },
|
13330 12826 | true,
|
13331 12827 | _diagnostic_collector,
|
13332 12828 | )
|
13333 12829 | })(&mut _diagnostic_collector),
|
13334 12830 | 36 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13335 - | let partition_result = &mut context.partition_result;
|
13336 - | let access_point_suffix = &mut context.access_point_suffix;
|
13337 - | let region_prefix = &mut context.region_prefix;
|
13338 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13339 - | let hardware_type = &mut context.hardware_type;
|
13340 - | let s3_e_ds = &mut context.s3_e_ds;
|
13341 - | let s3_e_fips = &mut context.s3_e_fips;
|
13342 - | let s3_e_auth = &mut context.s3_e_auth;
|
13343 - | let url = &mut context.url;
|
13344 - | let bucket_arn = &mut context.bucket_arn;
|
13345 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13346 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13347 - | let arn_type = &mut context.arn_type;
|
13348 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13349 - | let bucket_partition = &mut context.bucket_partition;
|
13350 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13351 - | let outpost_type = &mut context.outpost_type;
|
13352 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13353 12831 | let partition_resolver = &self.partition_resolver;
|
13354 12832 | (crate::endpoint_lib::coalesce::coalesce!(use_object_lambda_endpoint.clone(), false)) == (true)
|
13355 12833 | })(&mut _diagnostic_collector),
|
13356 12834 | 37 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13357 - | let partition_result = &mut context.partition_result;
|
13358 - | let access_point_suffix = &mut context.access_point_suffix;
|
13359 - | let region_prefix = &mut context.region_prefix;
|
13360 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13361 - | let hardware_type = &mut context.hardware_type;
|
13362 - | let s3_e_ds = &mut context.s3_e_ds;
|
13363 - | let s3_e_fips = &mut context.s3_e_fips;
|
13364 - | let s3_e_auth = &mut context.s3_e_auth;
|
13365 - | let url = &mut context.url;
|
13366 - | let bucket_arn = &mut context.bucket_arn;
|
13367 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13368 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12835 + | let bucket_arn = &context.bucket_arn;
|
13369 12836 | let arn_type = &mut context.arn_type;
|
13370 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13371 - | let bucket_partition = &mut context.bucket_partition;
|
13372 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13373 - | let outpost_type = &mut context.outpost_type;
|
13374 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13375 12837 | let partition_resolver = &self.partition_resolver;
|
13376 12838 | {
|
13377 12839 | *arn_type = if let Some(inner) = bucket_arn {
|
13378 12840 | inner.resource_id().first().cloned()
|
13379 12841 | } else {
|
13380 12842 | return false;
|
13381 12843 | }
|
13382 12844 | .map(|inner| inner.into());
|
13383 12845 | arn_type.is_some()
|
13384 12846 | }
|
13385 12847 | })(&mut _diagnostic_collector),
|
13386 12848 | 38 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13387 - | let partition_result = &mut context.partition_result;
|
13388 - | let access_point_suffix = &mut context.access_point_suffix;
|
13389 - | let region_prefix = &mut context.region_prefix;
|
13390 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13391 - | let hardware_type = &mut context.hardware_type;
|
13392 - | let s3_e_ds = &mut context.s3_e_ds;
|
13393 - | let s3_e_fips = &mut context.s3_e_fips;
|
13394 - | let s3_e_auth = &mut context.s3_e_auth;
|
13395 - | let url = &mut context.url;
|
13396 - | let bucket_arn = &mut context.bucket_arn;
|
13397 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13398 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13399 - | let arn_type = &mut context.arn_type;
|
13400 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13401 - | let bucket_partition = &mut context.bucket_partition;
|
13402 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13403 - | let outpost_type = &mut context.outpost_type;
|
13404 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12849 + | let arn_type = &context.arn_type;
|
13405 12850 | let partition_resolver = &self.partition_resolver;
|
13406 - | (arn_type) == &mut Some(("".into()))
|
12851 + | (arn_type) == &mut Some(("".to_string().into()))
|
13407 12852 | })(&mut _diagnostic_collector),
|
13408 12853 | 39 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13409 - | let partition_result = &mut context.partition_result;
|
13410 - | let access_point_suffix = &mut context.access_point_suffix;
|
13411 - | let region_prefix = &mut context.region_prefix;
|
13412 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13413 - | let hardware_type = &mut context.hardware_type;
|
13414 - | let s3_e_ds = &mut context.s3_e_ds;
|
13415 - | let s3_e_fips = &mut context.s3_e_fips;
|
13416 - | let s3_e_auth = &mut context.s3_e_auth;
|
13417 - | let url = &mut context.url;
|
13418 - | let bucket_arn = &mut context.bucket_arn;
|
13419 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13420 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13421 - | let arn_type = &mut context.arn_type;
|
13422 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13423 - | let bucket_partition = &mut context.bucket_partition;
|
13424 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13425 - | let outpost_type = &mut context.outpost_type;
|
13426 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12854 + | let arn_type = &context.arn_type;
|
13427 12855 | let partition_resolver = &self.partition_resolver;
|
13428 - | (arn_type) == &mut Some(("accesspoint".into()))
|
12856 + | (arn_type) == &mut Some(("accesspoint".to_string().into()))
|
13429 12857 | })(&mut _diagnostic_collector),
|
13430 12858 | 40 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13431 - | let partition_result = &mut context.partition_result;
|
13432 - | let access_point_suffix = &mut context.access_point_suffix;
|
13433 - | let region_prefix = &mut context.region_prefix;
|
13434 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13435 - | let hardware_type = &mut context.hardware_type;
|
13436 - | let s3_e_ds = &mut context.s3_e_ds;
|
13437 - | let s3_e_fips = &mut context.s3_e_fips;
|
13438 - | let s3_e_auth = &mut context.s3_e_auth;
|
13439 - | let url = &mut context.url;
|
13440 - | let bucket_arn = &mut context.bucket_arn;
|
13441 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13442 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13443 - | let arn_type = &mut context.arn_type;
|
12859 + | let bucket_arn = &context.bucket_arn;
|
13444 12860 | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13445 - | let bucket_partition = &mut context.bucket_partition;
|
13446 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13447 - | let outpost_type = &mut context.outpost_type;
|
13448 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13449 12861 | let partition_resolver = &self.partition_resolver;
|
13450 12862 | {
|
13451 12863 | *access_point_name_ssa_1 = if let Some(inner) = bucket_arn {
|
13452 12864 | inner.resource_id().get(1).cloned()
|
13453 12865 | } else {
|
13454 12866 | return false;
|
13455 12867 | }
|
13456 12868 | .map(|inner| inner.into());
|
13457 12869 | access_point_name_ssa_1.is_some()
|
13458 12870 | }
|
13459 12871 | })(&mut _diagnostic_collector),
|
13460 12872 | 41 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13461 - | let partition_result = &mut context.partition_result;
|
13462 - | let access_point_suffix = &mut context.access_point_suffix;
|
13463 - | let region_prefix = &mut context.region_prefix;
|
13464 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13465 - | let hardware_type = &mut context.hardware_type;
|
13466 - | let s3_e_ds = &mut context.s3_e_ds;
|
13467 - | let s3_e_fips = &mut context.s3_e_fips;
|
13468 - | let s3_e_auth = &mut context.s3_e_auth;
|
13469 - | let url = &mut context.url;
|
13470 - | let bucket_arn = &mut context.bucket_arn;
|
13471 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13472 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13473 - | let arn_type = &mut context.arn_type;
|
13474 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13475 - | let bucket_partition = &mut context.bucket_partition;
|
13476 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13477 - | let outpost_type = &mut context.outpost_type;
|
13478 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12873 + | let access_point_name_ssa_1 = &context.access_point_name_ssa_1;
|
13479 12874 | let partition_resolver = &self.partition_resolver;
|
13480 - | (access_point_name_ssa_1) == &mut Some(("".into()))
|
12875 + | (access_point_name_ssa_1) == &mut Some(("".to_string().into()))
|
13481 12876 | })(&mut _diagnostic_collector),
|
13482 12877 | 42 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13483 - | let partition_result = &mut context.partition_result;
|
13484 - | let access_point_suffix = &mut context.access_point_suffix;
|
13485 - | let region_prefix = &mut context.region_prefix;
|
13486 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13487 - | let hardware_type = &mut context.hardware_type;
|
13488 - | let s3_e_ds = &mut context.s3_e_ds;
|
13489 - | let s3_e_fips = &mut context.s3_e_fips;
|
13490 - | let s3_e_auth = &mut context.s3_e_auth;
|
13491 - | let url = &mut context.url;
|
13492 - | let bucket_arn = &mut context.bucket_arn;
|
13493 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13494 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13495 - | let arn_type = &mut context.arn_type;
|
13496 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13497 - | let bucket_partition = &mut context.bucket_partition;
|
13498 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13499 - | let outpost_type = &mut context.outpost_type;
|
13500 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12878 + | let bucket_arn = &context.bucket_arn;
|
13501 12879 | let partition_resolver = &self.partition_resolver;
|
13502 12880 | (if let Some(inner) = bucket_arn { inner.region() } else { return false }) == ("")
|
13503 12881 | })(&mut _diagnostic_collector),
|
13504 12882 | 43 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13505 - | let partition_result = &mut context.partition_result;
|
13506 - | let access_point_suffix = &mut context.access_point_suffix;
|
13507 - | let region_prefix = &mut context.region_prefix;
|
13508 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13509 - | let hardware_type = &mut context.hardware_type;
|
13510 - | let s3_e_ds = &mut context.s3_e_ds;
|
13511 - | let s3_e_fips = &mut context.s3_e_fips;
|
13512 - | let s3_e_auth = &mut context.s3_e_auth;
|
13513 - | let url = &mut context.url;
|
13514 - | let bucket_arn = &mut context.bucket_arn;
|
13515 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13516 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13517 - | let arn_type = &mut context.arn_type;
|
13518 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13519 - | let bucket_partition = &mut context.bucket_partition;
|
13520 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13521 - | let outpost_type = &mut context.outpost_type;
|
13522 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13523 12883 | let partition_resolver = &self.partition_resolver;
|
13524 12884 | (crate::endpoint_lib::coalesce::coalesce!(
|
13525 12885 | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
13526 12886 | if let Some(param) = bucket { param } else { return false },
|
13527 12887 | 14,
|
13528 12888 | 16,
|
13529 12889 | true,
|
13530 12890 | _diagnostic_collector
|
13531 12891 | ) {
|
13532 12892 | inner
|
13533 12893 | } else {
|
13534 12894 | return false;
|
13535 12895 | },
|
13536 12896 | "".to_string()
|
13537 12897 | )) == ("--")
|
13538 12898 | })(&mut _diagnostic_collector),
|
13539 12899 | 44 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13540 - | let partition_result = &mut context.partition_result;
|
13541 - | let access_point_suffix = &mut context.access_point_suffix;
|
13542 - | let region_prefix = &mut context.region_prefix;
|
13543 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13544 - | let hardware_type = &mut context.hardware_type;
|
13545 - | let s3_e_ds = &mut context.s3_e_ds;
|
13546 - | let s3_e_fips = &mut context.s3_e_fips;
|
13547 - | let s3_e_auth = &mut context.s3_e_auth;
|
13548 - | let url = &mut context.url;
|
13549 - | let bucket_arn = &mut context.bucket_arn;
|
13550 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13551 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13552 - | let arn_type = &mut context.arn_type;
|
13553 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13554 - | let bucket_partition = &mut context.bucket_partition;
|
13555 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13556 - | let outpost_type = &mut context.outpost_type;
|
13557 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12900 + | let hardware_type = &context.hardware_type;
|
13558 12901 | let partition_resolver = &self.partition_resolver;
|
13559 - | (hardware_type) == &mut Some(("e".into()))
|
12902 + | (hardware_type) == &mut Some(("e".to_string().into()))
|
13560 12903 | })(&mut _diagnostic_collector),
|
13561 12904 | 45 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13562 - | let partition_result = &mut context.partition_result;
|
13563 - | let access_point_suffix = &mut context.access_point_suffix;
|
13564 - | let region_prefix = &mut context.region_prefix;
|
13565 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13566 - | let hardware_type = &mut context.hardware_type;
|
13567 - | let s3_e_ds = &mut context.s3_e_ds;
|
13568 - | let s3_e_fips = &mut context.s3_e_fips;
|
13569 - | let s3_e_auth = &mut context.s3_e_auth;
|
13570 - | let url = &mut context.url;
|
13571 - | let bucket_arn = &mut context.bucket_arn;
|
13572 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13573 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13574 - | let arn_type = &mut context.arn_type;
|
13575 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13576 - | let bucket_partition = &mut context.bucket_partition;
|
13577 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13578 - | let outpost_type = &mut context.outpost_type;
|
13579 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12905 + | let hardware_type = &context.hardware_type;
|
13580 12906 | let partition_resolver = &self.partition_resolver;
|
13581 - | (hardware_type) == &mut Some(("o".into()))
|
12907 + | (hardware_type) == &mut Some(("o".to_string().into()))
|
13582 12908 | })(&mut _diagnostic_collector),
|
13583 12909 | 46 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13584 - | let partition_result = &mut context.partition_result;
|
13585 - | let access_point_suffix = &mut context.access_point_suffix;
|
13586 - | let region_prefix = &mut context.region_prefix;
|
13587 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13588 - | let hardware_type = &mut context.hardware_type;
|
13589 - | let s3_e_ds = &mut context.s3_e_ds;
|
13590 - | let s3_e_fips = &mut context.s3_e_fips;
|
13591 - | let s3_e_auth = &mut context.s3_e_auth;
|
13592 - | let url = &mut context.url;
|
13593 - | let bucket_arn = &mut context.bucket_arn;
|
13594 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13595 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13596 - | let arn_type = &mut context.arn_type;
|
13597 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13598 - | let bucket_partition = &mut context.bucket_partition;
|
13599 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13600 - | let outpost_type = &mut context.outpost_type;
|
13601 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13602 12910 | let partition_resolver = &self.partition_resolver;
|
13603 - | (region) == &mut Some(("aws-global".into()))
|
12911 + | (region) == &mut Some(("aws-global".to_string().into()))
|
13604 12912 | })(&mut _diagnostic_collector),
|
13605 12913 | 47 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13606 - | let partition_result = &mut context.partition_result;
|
13607 - | let access_point_suffix = &mut context.access_point_suffix;
|
13608 - | let region_prefix = &mut context.region_prefix;
|
13609 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13610 - | let hardware_type = &mut context.hardware_type;
|
13611 - | let s3_e_ds = &mut context.s3_e_ds;
|
13612 - | let s3_e_fips = &mut context.s3_e_fips;
|
13613 - | let s3_e_auth = &mut context.s3_e_auth;
|
13614 - | let url = &mut context.url;
|
13615 - | let bucket_arn = &mut context.bucket_arn;
|
13616 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13617 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13618 - | let arn_type = &mut context.arn_type;
|
13619 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13620 - | let bucket_partition = &mut context.bucket_partition;
|
13621 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13622 - | let outpost_type = &mut context.outpost_type;
|
13623 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13624 12914 | let partition_resolver = &self.partition_resolver;
|
13625 12915 | (crate::endpoint_lib::coalesce::coalesce!(
|
13626 12916 | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
13627 12917 | if let Some(param) = bucket { param } else { return false },
|
13628 12918 | 19,
|
13629 12919 | 21,
|
13630 12920 | true,
|
13631 12921 | _diagnostic_collector
|
13632 12922 | ) {
|
13633 12923 | inner
|
13634 12924 | } else {
|
13635 12925 | return false;
|
13636 12926 | },
|
13637 12927 | "".to_string()
|
13638 12928 | )) == ("--")
|
13639 12929 | })(&mut _diagnostic_collector),
|
13640 12930 | 48 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13641 - | let partition_result = &mut context.partition_result;
|
13642 - | let access_point_suffix = &mut context.access_point_suffix;
|
13643 - | let region_prefix = &mut context.region_prefix;
|
13644 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13645 - | let hardware_type = &mut context.hardware_type;
|
13646 - | let s3_e_ds = &mut context.s3_e_ds;
|
13647 - | let s3_e_fips = &mut context.s3_e_fips;
|
13648 - | let s3_e_auth = &mut context.s3_e_auth;
|
13649 - | let url = &mut context.url;
|
13650 - | let bucket_arn = &mut context.bucket_arn;
|
13651 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13652 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13653 - | let arn_type = &mut context.arn_type;
|
13654 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13655 - | let bucket_partition = &mut context.bucket_partition;
|
13656 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13657 - | let outpost_type = &mut context.outpost_type;
|
13658 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12931 + | let bucket_arn = &context.bucket_arn;
|
13659 12932 | let partition_resolver = &self.partition_resolver;
|
13660 12933 | (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3-object-lambda")
|
13661 12934 | })(&mut _diagnostic_collector),
|
13662 12935 | 49 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13663 - | let partition_result = &mut context.partition_result;
|
13664 - | let access_point_suffix = &mut context.access_point_suffix;
|
13665 - | let region_prefix = &mut context.region_prefix;
|
13666 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13667 - | let hardware_type = &mut context.hardware_type;
|
13668 - | let s3_e_ds = &mut context.s3_e_ds;
|
13669 - | let s3_e_fips = &mut context.s3_e_fips;
|
13670 - | let s3_e_auth = &mut context.s3_e_auth;
|
13671 - | let url = &mut context.url;
|
13672 - | let bucket_arn = &mut context.bucket_arn;
|
13673 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13674 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13675 - | let arn_type = &mut context.arn_type;
|
13676 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13677 - | let bucket_partition = &mut context.bucket_partition;
|
13678 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13679 - | let outpost_type = &mut context.outpost_type;
|
13680 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13681 12936 | let partition_resolver = &self.partition_resolver;
|
13682 12937 | (crate::endpoint_lib::coalesce::coalesce!(disable_access_points.clone(), false)) == (true)
|
13683 12938 | })(&mut _diagnostic_collector),
|
13684 12939 | 50 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13685 - | let partition_result = &mut context.partition_result;
|
13686 - | let access_point_suffix = &mut context.access_point_suffix;
|
13687 - | let region_prefix = &mut context.region_prefix;
|
13688 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13689 - | let hardware_type = &mut context.hardware_type;
|
13690 - | let s3_e_ds = &mut context.s3_e_ds;
|
13691 - | let s3_e_fips = &mut context.s3_e_fips;
|
13692 - | let s3_e_auth = &mut context.s3_e_auth;
|
13693 - | let url = &mut context.url;
|
13694 - | let bucket_arn = &mut context.bucket_arn;
|
13695 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13696 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13697 - | let arn_type = &mut context.arn_type;
|
13698 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13699 - | let bucket_partition = &mut context.bucket_partition;
|
13700 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13701 - | let outpost_type = &mut context.outpost_type;
|
13702 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12940 + | let bucket_arn = &context.bucket_arn;
|
13703 12941 | let partition_resolver = &self.partition_resolver;
|
13704 12942 | (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3-outposts")
|
13705 12943 | })(&mut _diagnostic_collector),
|
13706 12944 | 51 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13707 - | let partition_result = &mut context.partition_result;
|
13708 - | let access_point_suffix = &mut context.access_point_suffix;
|
13709 - | let region_prefix = &mut context.region_prefix;
|
13710 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13711 - | let hardware_type = &mut context.hardware_type;
|
13712 - | let s3_e_ds = &mut context.s3_e_ds;
|
13713 - | let s3_e_fips = &mut context.s3_e_fips;
|
13714 - | let s3_e_auth = &mut context.s3_e_auth;
|
13715 - | let url = &mut context.url;
|
13716 - | let bucket_arn = &mut context.bucket_arn;
|
13717 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13718 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13719 - | let arn_type = &mut context.arn_type;
|
13720 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12945 + | let bucket_arn = &context.bucket_arn;
|
13721 12946 | let bucket_partition = &mut context.bucket_partition;
|
13722 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13723 - | let outpost_type = &mut context.outpost_type;
|
13724 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13725 12947 | let partition_resolver = &self.partition_resolver;
|
13726 12948 | {
|
13727 12949 | *bucket_partition = partition_resolver
|
13728 12950 | .resolve_partition(
|
13729 12951 | if let Some(inner) = bucket_arn { inner.region() } else { return false },
|
13730 12952 | _diagnostic_collector,
|
13731 12953 | )
|
13732 12954 | .map(|inner| inner.into());
|
13733 12955 | bucket_partition.is_some()
|
13734 12956 | }
|
13735 12957 | })(&mut _diagnostic_collector),
|
13736 12958 | 52 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13737 - | let partition_result = &mut context.partition_result;
|
13738 - | let access_point_suffix = &mut context.access_point_suffix;
|
13739 - | let region_prefix = &mut context.region_prefix;
|
13740 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13741 - | let hardware_type = &mut context.hardware_type;
|
13742 - | let s3_e_ds = &mut context.s3_e_ds;
|
13743 - | let s3_e_fips = &mut context.s3_e_fips;
|
13744 - | let s3_e_auth = &mut context.s3_e_auth;
|
13745 - | let url = &mut context.url;
|
13746 - | let bucket_arn = &mut context.bucket_arn;
|
13747 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13748 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13749 - | let arn_type = &mut context.arn_type;
|
13750 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13751 - | let bucket_partition = &mut context.bucket_partition;
|
13752 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13753 - | let outpost_type = &mut context.outpost_type;
|
13754 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12959 + | let access_point_name_ssa_1 = &context.access_point_name_ssa_1;
|
13755 12960 | let partition_resolver = &self.partition_resolver;
|
13756 12961 | crate::endpoint_lib::host::is_valid_host_label(
|
13757 12962 | if let Some(param) = access_point_name_ssa_1 {
|
13758 12963 | param
|
13759 12964 | } else {
|
13760 12965 | return false;
|
13761 12966 | },
|
13762 12967 | true,
|
13763 12968 | _diagnostic_collector,
|
13764 12969 | )
|
13765 12970 | })(&mut _diagnostic_collector),
|
13766 12971 | 53 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13767 - | let partition_result = &mut context.partition_result;
|
13768 - | let access_point_suffix = &mut context.access_point_suffix;
|
13769 - | let region_prefix = &mut context.region_prefix;
|
13770 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13771 - | let hardware_type = &mut context.hardware_type;
|
13772 - | let s3_e_ds = &mut context.s3_e_ds;
|
13773 - | let s3_e_fips = &mut context.s3_e_fips;
|
13774 - | let s3_e_auth = &mut context.s3_e_auth;
|
13775 - | let url = &mut context.url;
|
13776 - | let bucket_arn = &mut context.bucket_arn;
|
13777 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13778 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13779 - | let arn_type = &mut context.arn_type;
|
13780 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13781 - | let bucket_partition = &mut context.bucket_partition;
|
13782 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13783 - | let outpost_type = &mut context.outpost_type;
|
13784 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13785 12972 | let partition_resolver = &self.partition_resolver;
|
13786 12973 | (crate::endpoint_lib::coalesce::coalesce!(
|
13787 12974 | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
13788 12975 | if let Some(param) = bucket { param } else { return false },
|
13789 12976 | 26,
|
13790 12977 | 28,
|
13791 12978 | true,
|
13792 12979 | _diagnostic_collector
|
13793 12980 | ) {
|
13794 12981 | inner
|
13795 12982 | } else {
|
13796 12983 | return false;
|
13797 12984 | },
|
13798 12985 | "".to_string()
|
13799 12986 | )) == ("--")
|
13800 12987 | })(&mut _diagnostic_collector),
|
13801 12988 | 54 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13802 - | let partition_result = &mut context.partition_result;
|
13803 - | let access_point_suffix = &mut context.access_point_suffix;
|
13804 - | let region_prefix = &mut context.region_prefix;
|
13805 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13806 - | let hardware_type = &mut context.hardware_type;
|
13807 - | let s3_e_ds = &mut context.s3_e_ds;
|
13808 - | let s3_e_fips = &mut context.s3_e_fips;
|
13809 - | let s3_e_auth = &mut context.s3_e_auth;
|
13810 - | let url = &mut context.url;
|
13811 - | let bucket_arn = &mut context.bucket_arn;
|
13812 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13813 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13814 - | let arn_type = &mut context.arn_type;
|
13815 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13816 - | let bucket_partition = &mut context.bucket_partition;
|
13817 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13818 - | let outpost_type = &mut context.outpost_type;
|
13819 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13820 12989 | let partition_resolver = &self.partition_resolver;
|
13821 12990 | (crate::endpoint_lib::coalesce::coalesce!(
|
13822 12991 | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
13823 12992 | if let Some(param) = bucket { param } else { return false },
|
13824 12993 | 15,
|
13825 12994 | 17,
|
13826 12995 | true,
|
13827 12996 | _diagnostic_collector
|
13828 12997 | ) {
|
13829 12998 | inner
|
13830 12999 | } else {
|
13831 13000 | return false;
|
13832 13001 | },
|
13833 13002 | "".to_string()
|
13834 13003 | )) == ("--")
|
13835 13004 | })(&mut _diagnostic_collector),
|
13836 13005 | 55 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13837 - | let partition_result = &mut context.partition_result;
|
13838 - | let access_point_suffix = &mut context.access_point_suffix;
|
13839 - | let region_prefix = &mut context.region_prefix;
|
13840 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13841 - | let hardware_type = &mut context.hardware_type;
|
13842 - | let s3_e_ds = &mut context.s3_e_ds;
|
13843 - | let s3_e_fips = &mut context.s3_e_fips;
|
13844 - | let s3_e_auth = &mut context.s3_e_auth;
|
13845 - | let url = &mut context.url;
|
13846 - | let bucket_arn = &mut context.bucket_arn;
|
13847 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13848 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13849 - | let arn_type = &mut context.arn_type;
|
13850 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13851 - | let bucket_partition = &mut context.bucket_partition;
|
13852 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13853 - | let outpost_type = &mut context.outpost_type;
|
13854 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13006 + | let bucket_arn = &context.bucket_arn;
|
13855 13007 | let partition_resolver = &self.partition_resolver;
|
13856 13008 | if let Some(inner) = bucket_arn {
|
13857 13009 | inner.resource_id().get(4).cloned()
|
13858 13010 | } else {
|
13859 13011 | return false;
|
13860 13012 | }
|
13861 13013 | .is_some()
|
13862 13014 | })(&mut _diagnostic_collector),
|
13863 13015 | 56 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13864 - | let partition_result = &mut context.partition_result;
|
13865 - | let access_point_suffix = &mut context.access_point_suffix;
|
13866 - | let region_prefix = &mut context.region_prefix;
|
13867 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13868 - | let hardware_type = &mut context.hardware_type;
|
13869 - | let s3_e_ds = &mut context.s3_e_ds;
|
13870 - | let s3_e_fips = &mut context.s3_e_fips;
|
13871 - | let s3_e_auth = &mut context.s3_e_auth;
|
13872 - | let url = &mut context.url;
|
13873 - | let bucket_arn = &mut context.bucket_arn;
|
13874 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13875 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13876 - | let arn_type = &mut context.arn_type;
|
13877 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13878 - | let bucket_partition = &mut context.bucket_partition;
|
13879 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13880 - | let outpost_type = &mut context.outpost_type;
|
13881 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13882 13016 | let partition_resolver = &self.partition_resolver;
|
13883 13017 | (crate::endpoint_lib::coalesce::coalesce!(
|
13884 13018 | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
13885 13019 | if let Some(param) = bucket { param } else { return false },
|
13886 13020 | 20,
|
13887 13021 | 22,
|
13888 13022 | true,
|
13889 13023 | _diagnostic_collector
|
13890 13024 | ) {
|
13891 13025 | inner
|
13892 13026 | } else {
|
13893 - | return false;
|
13894 - | },
|
13895 - | "".to_string()
|
13896 - | )) == ("--")
|
13897 - | })(&mut _diagnostic_collector),
|
13898 - | 57 => (use_global_endpoint) == (&true),
|
13899 - | 58 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13900 - | let partition_result = &mut context.partition_result;
|
13901 - | let access_point_suffix = &mut context.access_point_suffix;
|
13902 - | let region_prefix = &mut context.region_prefix;
|
13903 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13904 - | let hardware_type = &mut context.hardware_type;
|
13905 - | let s3_e_ds = &mut context.s3_e_ds;
|
13906 - | let s3_e_fips = &mut context.s3_e_fips;
|
13907 - | let s3_e_auth = &mut context.s3_e_auth;
|
13908 - | let url = &mut context.url;
|
13909 - | let bucket_arn = &mut context.bucket_arn;
|
13910 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13911 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13912 - | let arn_type = &mut context.arn_type;
|
13913 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13914 - | let bucket_partition = &mut context.bucket_partition;
|
13915 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13916 - | let outpost_type = &mut context.outpost_type;
|
13917 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13027 + | return false;
|
13028 + | },
|
13029 + | "".to_string()
|
13030 + | )) == ("--")
|
13031 + | })(&mut _diagnostic_collector),
|
13032 + | 57 => (use_global_endpoint) == (&true),
|
13033 + | 58 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13918 13034 | let partition_resolver = &self.partition_resolver;
|
13919 - | (region) == &mut Some(("us-east-1".into()))
|
13035 + | (region) == &mut Some(("us-east-1".to_string().into()))
|
13920 13036 | })(&mut _diagnostic_collector),
|
13921 13037 | 59 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13922 - | let partition_result = &mut context.partition_result;
|
13923 - | let access_point_suffix = &mut context.access_point_suffix;
|
13924 - | let region_prefix = &mut context.region_prefix;
|
13925 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13926 - | let hardware_type = &mut context.hardware_type;
|
13927 - | let s3_e_ds = &mut context.s3_e_ds;
|
13928 - | let s3_e_fips = &mut context.s3_e_fips;
|
13929 - | let s3_e_auth = &mut context.s3_e_auth;
|
13930 - | let url = &mut context.url;
|
13931 - | let bucket_arn = &mut context.bucket_arn;
|
13932 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13933 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13934 - | let arn_type = &mut context.arn_type;
|
13935 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13936 - | let bucket_partition = &mut context.bucket_partition;
|
13038 + | let bucket_arn = &context.bucket_arn;
|
13937 13039 | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13938 - | let outpost_type = &mut context.outpost_type;
|
13939 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13940 13040 | let partition_resolver = &self.partition_resolver;
|
13941 13041 | {
|
13942 13042 | *outpost_id_ssa_1 = if let Some(inner) = bucket_arn {
|
13943 13043 | inner.resource_id().get(1).cloned()
|
13944 13044 | } else {
|
13945 13045 | return false;
|
13946 13046 | }
|
13947 13047 | .map(|inner| inner.into());
|
13948 13048 | outpost_id_ssa_1.is_some()
|
13949 13049 | }
|
13950 13050 | })(&mut _diagnostic_collector),
|
13951 13051 | 60 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13952 - | let partition_result = &mut context.partition_result;
|
13953 - | let access_point_suffix = &mut context.access_point_suffix;
|
13954 - | let region_prefix = &mut context.region_prefix;
|
13955 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13956 - | let hardware_type = &mut context.hardware_type;
|
13957 - | let s3_e_ds = &mut context.s3_e_ds;
|
13958 - | let s3_e_fips = &mut context.s3_e_fips;
|
13959 - | let s3_e_auth = &mut context.s3_e_auth;
|
13960 - | let url = &mut context.url;
|
13961 - | let bucket_arn = &mut context.bucket_arn;
|
13962 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13963 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13964 - | let arn_type = &mut context.arn_type;
|
13965 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13966 - | let bucket_partition = &mut context.bucket_partition;
|
13967 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13968 - | let outpost_type = &mut context.outpost_type;
|
13969 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13970 13052 | let partition_resolver = &self.partition_resolver;
|
13971 13053 | (crate::endpoint_lib::coalesce::coalesce!(use_arn_region.clone(), true)) == (true)
|
13972 13054 | })(&mut _diagnostic_collector),
|
13973 13055 | 61 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
13974 - | let partition_result = &mut context.partition_result;
|
13975 - | let access_point_suffix = &mut context.access_point_suffix;
|
13976 - | let region_prefix = &mut context.region_prefix;
|
13977 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
13978 - | let hardware_type = &mut context.hardware_type;
|
13979 - | let s3_e_ds = &mut context.s3_e_ds;
|
13980 - | let s3_e_fips = &mut context.s3_e_fips;
|
13981 - | let s3_e_auth = &mut context.s3_e_auth;
|
13982 - | let url = &mut context.url;
|
13983 - | let bucket_arn = &mut context.bucket_arn;
|
13984 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
13985 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
13986 - | let arn_type = &mut context.arn_type;
|
13987 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
13988 - | let bucket_partition = &mut context.bucket_partition;
|
13989 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13990 - | let outpost_type = &mut context.outpost_type;
|
13991 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13056 + | let outpost_id_ssa_1 = &context.outpost_id_ssa_1;
|
13992 13057 | let partition_resolver = &self.partition_resolver;
|
13993 13058 | crate::endpoint_lib::host::is_valid_host_label(
|
13994 13059 | if let Some(param) = outpost_id_ssa_1 { param } else { return false },
|
13995 13060 | false,
|
13996 13061 | _diagnostic_collector,
|
13997 13062 | )
|
13998 13063 | })(&mut _diagnostic_collector),
|
13999 13064 | 62 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
14000 - | let partition_result = &mut context.partition_result;
|
14001 - | let access_point_suffix = &mut context.access_point_suffix;
|
14002 - | let region_prefix = &mut context.region_prefix;
|
14003 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
14004 - | let hardware_type = &mut context.hardware_type;
|
14005 - | let s3_e_ds = &mut context.s3_e_ds;
|
14006 - | let s3_e_fips = &mut context.s3_e_fips;
|
14007 - | let s3_e_auth = &mut context.s3_e_auth;
|
14008 - | let url = &mut context.url;
|
14009 - | let bucket_arn = &mut context.bucket_arn;
|
14010 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
14011 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
14012 - | let arn_type = &mut context.arn_type;
|
14013 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
14014 - | let bucket_partition = &mut context.bucket_partition;
|
14015 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
13065 + | let bucket_arn = &context.bucket_arn;
|
14016 13066 | let outpost_type = &mut context.outpost_type;
|
14017 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
14018 13067 | let partition_resolver = &self.partition_resolver;
|
14019 13068 | {
|
14020 13069 | *outpost_type = if let Some(inner) = bucket_arn {
|
14021 13070 | inner.resource_id().get(2).cloned()
|
14022 13071 | } else {
|
14023 13072 | return false;
|
14024 13073 | }
|
14025 13074 | .map(|inner| inner.into());
|
14026 13075 | outpost_type.is_some()
|
14027 13076 | }
|
14028 13077 | })(&mut _diagnostic_collector),
|
14029 13078 | 63 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
14030 - | let partition_result = &mut context.partition_result;
|
14031 - | let access_point_suffix = &mut context.access_point_suffix;
|
14032 - | let region_prefix = &mut context.region_prefix;
|
14033 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
14034 - | let hardware_type = &mut context.hardware_type;
|
14035 - | let s3_e_ds = &mut context.s3_e_ds;
|
14036 - | let s3_e_fips = &mut context.s3_e_fips;
|
14037 - | let s3_e_auth = &mut context.s3_e_auth;
|
14038 - | let url = &mut context.url;
|
14039 - | let bucket_arn = &mut context.bucket_arn;
|
14040 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
14041 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
14042 - | let arn_type = &mut context.arn_type;
|
14043 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
14044 - | let bucket_partition = &mut context.bucket_partition;
|
14045 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
14046 - | let outpost_type = &mut context.outpost_type;
|
14047 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13079 + | let bucket_arn = &context.bucket_arn;
|
14048 13080 | let partition_resolver = &self.partition_resolver;
|
14049 13081 | (region) == &mut Some((if let Some(inner) = bucket_arn { inner.region() } else { return false }.into()))
|
14050 13082 | })(&mut _diagnostic_collector),
|
14051 13083 | 64 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
14052 - | let partition_result = &mut context.partition_result;
|
14053 - | let access_point_suffix = &mut context.access_point_suffix;
|
14054 - | let region_prefix = &mut context.region_prefix;
|
14055 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
14056 - | let hardware_type = &mut context.hardware_type;
|
14057 - | let s3_e_ds = &mut context.s3_e_ds;
|
14058 - | let s3_e_fips = &mut context.s3_e_fips;
|
14059 - | let s3_e_auth = &mut context.s3_e_auth;
|
14060 - | let url = &mut context.url;
|
14061 - | let bucket_arn = &mut context.bucket_arn;
|
14062 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
14063 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
14064 - | let arn_type = &mut context.arn_type;
|
14065 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
14066 - | let bucket_partition = &mut context.bucket_partition;
|
14067 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
14068 - | let outpost_type = &mut context.outpost_type;
|
14069 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13084 + | let partition_result = &context.partition_result;
|
13085 + | let bucket_partition = &context.bucket_partition;
|
14070 13086 | let partition_resolver = &self.partition_resolver;
|
14071 13087 | (if let Some(inner) = bucket_partition {
|
14072 13088 | inner.name()
|
14073 13089 | } else {
|
14074 13090 | return false;
|
14075 13091 | }) == (if let Some(inner) = partition_result {
|
14076 13092 | inner.name()
|
14077 13093 | } else {
|
14078 13094 | return false;
|
14079 13095 | })
|
14080 13096 | })(&mut _diagnostic_collector),
|
14081 13097 | 65 => (disable_multi_region_access_points) == (&true),
|
14082 13098 | 66 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
14083 - | let partition_result = &mut context.partition_result;
|
14084 - | let access_point_suffix = &mut context.access_point_suffix;
|
14085 - | let region_prefix = &mut context.region_prefix;
|
14086 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
14087 - | let hardware_type = &mut context.hardware_type;
|
14088 - | let s3_e_ds = &mut context.s3_e_ds;
|
14089 - | let s3_e_fips = &mut context.s3_e_fips;
|
14090 - | let s3_e_auth = &mut context.s3_e_auth;
|
14091 - | let url = &mut context.url;
|
14092 - | let bucket_arn = &mut context.bucket_arn;
|
14093 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
14094 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
14095 - | let arn_type = &mut context.arn_type;
|
14096 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
14097 - | let bucket_partition = &mut context.bucket_partition;
|
14098 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
14099 - | let outpost_type = &mut context.outpost_type;
|
14100 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13099 + | let bucket_arn = &context.bucket_arn;
|
14101 13100 | let partition_resolver = &self.partition_resolver;
|
14102 13101 | crate::endpoint_lib::host::is_valid_host_label(
|
14103 13102 | if let Some(inner) = bucket_arn { inner.region() } else { return false },
|
14104 13103 | true,
|
14105 13104 | _diagnostic_collector,
|
14106 13105 | )
|
14107 13106 | })(&mut _diagnostic_collector),
|
14108 13107 | 67 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
14109 - | let partition_result = &mut context.partition_result;
|
14110 - | let access_point_suffix = &mut context.access_point_suffix;
|
14111 - | let region_prefix = &mut context.region_prefix;
|
14112 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
14113 - | let hardware_type = &mut context.hardware_type;
|
14114 - | let s3_e_ds = &mut context.s3_e_ds;
|
14115 - | let s3_e_fips = &mut context.s3_e_fips;
|
14116 - | let s3_e_auth = &mut context.s3_e_auth;
|
14117 - | let url = &mut context.url;
|
14118 - | let bucket_arn = &mut context.bucket_arn;
|
14119 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
14120 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
14121 - | let arn_type = &mut context.arn_type;
|
14122 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
14123 - | let bucket_partition = &mut context.bucket_partition;
|
14124 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
14125 - | let outpost_type = &mut context.outpost_type;
|
14126 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13108 + | let partition_result = &context.partition_result;
|
13109 + | let bucket_arn = &context.bucket_arn;
|
14127 13110 | let partition_resolver = &self.partition_resolver;
|
14128 13111 | (if let Some(inner) = bucket_arn { inner.partition() } else { return false })
|
14129 13112 | == (if let Some(inner) = partition_result {
|
14130 13113 | inner.name()
|
14131 13114 | } else {
|
14132 13115 | return false;
|
14133 13116 | })
|
14134 13117 | })(&mut _diagnostic_collector),
|
14135 13118 | 68 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
14136 - | let partition_result = &mut context.partition_result;
|
14137 - | let access_point_suffix = &mut context.access_point_suffix;
|
14138 - | let region_prefix = &mut context.region_prefix;
|
14139 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
14140 - | let hardware_type = &mut context.hardware_type;
|
14141 - | let s3_e_ds = &mut context.s3_e_ds;
|
14142 - | let s3_e_fips = &mut context.s3_e_fips;
|
14143 - | let s3_e_auth = &mut context.s3_e_auth;
|
14144 - | let url = &mut context.url;
|
14145 - | let bucket_arn = &mut context.bucket_arn;
|
14146 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
14147 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
14148 - | let arn_type = &mut context.arn_type;
|
14149 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
14150 - | let bucket_partition = &mut context.bucket_partition;
|
14151 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
14152 - | let outpost_type = &mut context.outpost_type;
|
14153 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13119 + | let bucket_arn = &context.bucket_arn;
|
14154 13120 | let partition_resolver = &self.partition_resolver;
|
14155 13121 | (if let Some(inner) = bucket_arn {
|
14156 13122 | inner.account_id()
|
14157 13123 | } else {
|
14158 13124 | return false;
|
14159 13125 | }) == ("")
|
14160 13126 | })(&mut _diagnostic_collector),
|
14161 13127 | 69 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
14162 - | let partition_result = &mut context.partition_result;
|
14163 - | let access_point_suffix = &mut context.access_point_suffix;
|
14164 - | let region_prefix = &mut context.region_prefix;
|
14165 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
14166 - | let hardware_type = &mut context.hardware_type;
|
14167 - | let s3_e_ds = &mut context.s3_e_ds;
|
14168 - | let s3_e_fips = &mut context.s3_e_fips;
|
14169 - | let s3_e_auth = &mut context.s3_e_auth;
|
14170 - | let url = &mut context.url;
|
14171 - | let bucket_arn = &mut context.bucket_arn;
|
14172 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
14173 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
14174 - | let arn_type = &mut context.arn_type;
|
14175 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
14176 - | let bucket_partition = &mut context.bucket_partition;
|
14177 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
14178 - | let outpost_type = &mut context.outpost_type;
|
14179 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13128 + | let bucket_arn = &context.bucket_arn;
|
14180 13129 | let partition_resolver = &self.partition_resolver;
|
14181 13130 | (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3")
|
14182 13131 | })(&mut _diagnostic_collector),
|
14183 13132 | 70 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
14184 - | let partition_result = &mut context.partition_result;
|
14185 - | let access_point_suffix = &mut context.access_point_suffix;
|
14186 - | let region_prefix = &mut context.region_prefix;
|
14187 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
14188 - | let hardware_type = &mut context.hardware_type;
|
14189 - | let s3_e_ds = &mut context.s3_e_ds;
|
14190 - | let s3_e_fips = &mut context.s3_e_fips;
|
14191 - | let s3_e_auth = &mut context.s3_e_auth;
|
14192 - | let url = &mut context.url;
|
14193 - | let bucket_arn = &mut context.bucket_arn;
|
14194 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
14195 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
14196 - | let arn_type = &mut context.arn_type;
|
14197 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
14198 - | let bucket_partition = &mut context.bucket_partition;
|
14199 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
14200 - | let outpost_type = &mut context.outpost_type;
|
14201 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13133 + | let bucket_arn = &context.bucket_arn;
|
14202 13134 | let partition_resolver = &self.partition_resolver;
|
14203 13135 | crate::endpoint_lib::host::is_valid_host_label(
|
14204 13136 | if let Some(inner) = bucket_arn {
|
14205 13137 | inner.account_id()
|
14206 13138 | } else {
|
14207 13139 | return false;
|
14208 13140 | },
|
14209 13141 | false,
|
14210 13142 | _diagnostic_collector,
|
14211 13143 | )
|
14212 13144 | })(&mut _diagnostic_collector),
|
14213 13145 | 71 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
14214 - | let partition_result = &mut context.partition_result;
|
14215 - | let access_point_suffix = &mut context.access_point_suffix;
|
14216 - | let region_prefix = &mut context.region_prefix;
|
14217 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
14218 - | let hardware_type = &mut context.hardware_type;
|
14219 - | let s3_e_ds = &mut context.s3_e_ds;
|
14220 - | let s3_e_fips = &mut context.s3_e_fips;
|
14221 - | let s3_e_auth = &mut context.s3_e_auth;
|
14222 - | let url = &mut context.url;
|
14223 - | let bucket_arn = &mut context.bucket_arn;
|
14224 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
14225 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
14226 - | let arn_type = &mut context.arn_type;
|
14227 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
14228 - | let bucket_partition = &mut context.bucket_partition;
|
14229 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
14230 - | let outpost_type = &mut context.outpost_type;
|
13146 + | let bucket_arn = &context.bucket_arn;
|
14231 13147 | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
14232 13148 | let partition_resolver = &self.partition_resolver;
|
14233 13149 | {
|
14234 13150 | *access_point_name_ssa_2 = if let Some(inner) = bucket_arn {
|
14235 13151 | inner.resource_id().get(3).cloned()
|
14236 13152 | } else {
|
14237 13153 | return false;
|
14238 13154 | }
|
14239 13155 | .map(|inner| inner.into());
|
14240 13156 | access_point_name_ssa_2.is_some()
|
14241 13157 | }
|
14242 13158 | })(&mut _diagnostic_collector),
|
14243 13159 | 72 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
14244 - | let partition_result = &mut context.partition_result;
|
14245 - | let access_point_suffix = &mut context.access_point_suffix;
|
14246 - | let region_prefix = &mut context.region_prefix;
|
14247 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
14248 - | let hardware_type = &mut context.hardware_type;
|
14249 - | let s3_e_ds = &mut context.s3_e_ds;
|
14250 - | let s3_e_fips = &mut context.s3_e_fips;
|
14251 - | let s3_e_auth = &mut context.s3_e_auth;
|
14252 - | let url = &mut context.url;
|
14253 - | let bucket_arn = &mut context.bucket_arn;
|
14254 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
14255 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
14256 - | let arn_type = &mut context.arn_type;
|
14257 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
14258 - | let bucket_partition = &mut context.bucket_partition;
|
14259 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
14260 - | let outpost_type = &mut context.outpost_type;
|
14261 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13160 + | let access_point_name_ssa_1 = &context.access_point_name_ssa_1;
|
14262 13161 | let partition_resolver = &self.partition_resolver;
|
14263 13162 | crate::endpoint_lib::host::is_valid_host_label(
|
14264 13163 | if let Some(param) = access_point_name_ssa_1 {
|
14265 13164 | param
|
14266 13165 | } else {
|
14267 13166 | return false;
|
14268 13167 | },
|
14269 13168 | false,
|
14270 13169 | _diagnostic_collector,
|
14271 13170 | )
|
14272 13171 | })(&mut _diagnostic_collector),
|
14273 13172 | 73 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
|
14274 - | let partition_result = &mut context.partition_result;
|
14275 - | let access_point_suffix = &mut context.access_point_suffix;
|
14276 - | let region_prefix = &mut context.region_prefix;
|
14277 - | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
14278 - | let hardware_type = &mut context.hardware_type;
|
14279 - | let s3_e_ds = &mut context.s3_e_ds;
|
14280 - | let s3_e_fips = &mut context.s3_e_fips;
|
14281 - | let s3_e_auth = &mut context.s3_e_auth;
|
14282 - | let url = &mut context.url;
|
14283 - | let bucket_arn = &mut context.bucket_arn;
|
14284 - | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
14285 - | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
14286 - | let arn_type = &mut context.arn_type;
|
14287 - | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
14288 - | let bucket_partition = &mut context.bucket_partition;
|
14289 - | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
14290 - | let outpost_type = &mut context.outpost_type;
|
14291 - | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
13173 + | let outpost_type = &context.outpost_type;
|
14292 13174 | let partition_resolver = &self.partition_resolver;
|
14293 - | (outpost_type) == &mut Some(("accesspoint".into()))
|
13175 + | (outpost_type) == &mut Some(("accesspoint".to_string().into()))
|
14294 13176 | })(&mut _diagnostic_collector),
|
14295 13177 | _ => unreachable!("Invalid condition index"),
|
14296 13178 | };
|
14297 13179 | current_ref = if is_complement ^ condition_result { node.high_ref } else { node.low_ref };
|
14298 13180 | }
|
14299 13181 | }
|
14300 13182 | }
|
14301 13183 | }
|
14302 13184 | }
|
14303 13185 |
|