#[non_exhaustive]
pub struct ClientVpnEndpoint { /* private fields */ }
Expand description

Describes a Client VPN endpoint.

Implementations§

The ID of the Client VPN endpoint.

A brief description of the endpoint.

The current state of the Client VPN endpoint.

The date and time the Client VPN endpoint was created.

The date and time the Client VPN endpoint was deleted, if applicable.

The DNS name to be used by clients when connecting to the Client VPN endpoint.

The IPv4 address range, in CIDR notation, from which client IP addresses are assigned.

Information about the DNS servers to be used for DNS resolution.

Indicates whether split-tunnel is enabled in the Client VPN endpoint.

For information about split-tunnel VPN endpoints, see Split-Tunnel Client VPN endpoint in the Client VPN Administrator Guide.

The protocol used by the VPN session.

The transport protocol used by the Client VPN endpoint.

The port number for the Client VPN endpoint.

👎Deprecated: This property is deprecated. To view the target networks associated with a Client VPN endpoint, call DescribeClientVpnTargetNetworks and inspect the clientVpnTargetNetworks response element.

Information about the associated target networks. A target network is a subnet in a VPC.

The ARN of the server certificate.

Information about the authentication method used by the Client VPN endpoint.

Information about the client connection logging options for the Client VPN endpoint.

Any tags assigned to the Client VPN endpoint.

The IDs of the security groups for the target network.

The ID of the VPC.

The URL of the self-service portal.

The options for managing connection authorization for new client connections.

The maximum VPN session duration time in hours.

Valid values: 8 | 10 | 12 | 24

Default value: 24

Options for enabling a customizable text banner that will be displayed on Amazon Web Services provided clients when a VPN session is established.

Creates a new builder-style object to manufacture ClientVpnEndpoint.

Examples found in repository?
src/xml_deser.rs (line 43724)
43720
43721
43722
43723
43724
43725
43726
43727
43728
43729
43730
43731
43732
43733
43734
43735
43736
43737
43738
43739
43740
43741
43742
43743
43744
43745
43746
43747
43748
43749
43750
43751
43752
43753
43754
43755
43756
43757
43758
43759
43760
43761
43762
43763
43764
43765
43766
43767
43768
43769
43770
43771
43772
43773
43774
43775
43776
43777
43778
43779
43780
43781
43782
43783
43784
43785
43786
43787
43788
43789
43790
43791
43792
43793
43794
43795
43796
43797
43798
43799
43800
43801
43802
43803
43804
43805
43806
43807
43808
43809
43810
43811
43812
43813
43814
43815
43816
43817
43818
43819
43820
43821
43822
43823
43824
43825
43826
43827
43828
43829
43830
43831
43832
43833
43834
43835
43836
43837
43838
43839
43840
43841
43842
43843
43844
43845
43846
43847
43848
43849
43850
43851
43852
43853
43854
43855
43856
43857
43858
43859
43860
43861
43862
43863
43864
43865
43866
43867
43868
43869
43870
43871
43872
43873
43874
43875
43876
43877
43878
43879
43880
43881
43882
43883
43884
43885
43886
43887
43888
43889
43890
43891
43892
43893
43894
43895
43896
43897
43898
43899
43900
43901
43902
43903
43904
43905
43906
43907
43908
43909
43910
43911
43912
43913
43914
43915
43916
43917
43918
43919
43920
43921
43922
43923
43924
43925
43926
43927
43928
43929
43930
43931
43932
43933
43934
43935
43936
43937
43938
43939
43940
43941
43942
43943
43944
43945
43946
43947
43948
43949
43950
43951
43952
43953
43954
43955
43956
43957
43958
43959
43960
43961
43962
43963
43964
43965
43966
43967
43968
43969
43970
43971
43972
43973
43974
43975
43976
43977
43978
43979
43980
43981
43982
43983
43984
43985
43986
43987
43988
43989
43990
43991
43992
43993
43994
43995
43996
43997
43998
43999
44000
44001
44002
44003
44004
44005
44006
44007
44008
44009
44010
44011
pub fn deser_structure_crate_model_client_vpn_endpoint(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::ClientVpnEndpoint, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::ClientVpnEndpoint::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("clientVpnEndpointId") /* ClientVpnEndpointId com.amazonaws.ec2#ClientVpnEndpoint$ClientVpnEndpointId */ =>  {
                let var_1900 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_client_vpn_endpoint_id(var_1900);
            }
            ,
            s if s.matches("description") /* Description com.amazonaws.ec2#ClientVpnEndpoint$Description */ =>  {
                let var_1901 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_description(var_1901);
            }
            ,
            s if s.matches("status") /* Status com.amazonaws.ec2#ClientVpnEndpoint$Status */ =>  {
                let var_1902 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_client_vpn_endpoint_status(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_status(var_1902);
            }
            ,
            s if s.matches("creationTime") /* CreationTime com.amazonaws.ec2#ClientVpnEndpoint$CreationTime */ =>  {
                let var_1903 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_creation_time(var_1903);
            }
            ,
            s if s.matches("deletionTime") /* DeletionTime com.amazonaws.ec2#ClientVpnEndpoint$DeletionTime */ =>  {
                let var_1904 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_deletion_time(var_1904);
            }
            ,
            s if s.matches("dnsName") /* DnsName com.amazonaws.ec2#ClientVpnEndpoint$DnsName */ =>  {
                let var_1905 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_dns_name(var_1905);
            }
            ,
            s if s.matches("clientCidrBlock") /* ClientCidrBlock com.amazonaws.ec2#ClientVpnEndpoint$ClientCidrBlock */ =>  {
                let var_1906 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_client_cidr_block(var_1906);
            }
            ,
            s if s.matches("dnsServer") /* DnsServers com.amazonaws.ec2#ClientVpnEndpoint$DnsServers */ =>  {
                let var_1907 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_value_string_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_dns_servers(var_1907);
            }
            ,
            s if s.matches("splitTunnel") /* SplitTunnel com.amazonaws.ec2#ClientVpnEndpoint$SplitTunnel */ =>  {
                let var_1908 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.ec2#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_split_tunnel(var_1908);
            }
            ,
            s if s.matches("vpnProtocol") /* VpnProtocol com.amazonaws.ec2#ClientVpnEndpoint$VpnProtocol */ =>  {
                let var_1909 =
                    Some(
                        Result::<crate::model::VpnProtocol, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::VpnProtocol::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_vpn_protocol(var_1909);
            }
            ,
            s if s.matches("transportProtocol") /* TransportProtocol com.amazonaws.ec2#ClientVpnEndpoint$TransportProtocol */ =>  {
                let var_1910 =
                    Some(
                        Result::<crate::model::TransportProtocol, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::TransportProtocol::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_transport_protocol(var_1910);
            }
            ,
            s if s.matches("vpnPort") /* VpnPort com.amazonaws.ec2#ClientVpnEndpoint$VpnPort */ =>  {
                let var_1911 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_vpn_port(var_1911);
            }
            ,
            s if s.matches("associatedTargetNetwork") /* AssociatedTargetNetworks com.amazonaws.ec2#ClientVpnEndpoint$AssociatedTargetNetworks */ =>  {
                let var_1912 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_associated_target_network_set(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_associated_target_networks(var_1912);
            }
            ,
            s if s.matches("serverCertificateArn") /* ServerCertificateArn com.amazonaws.ec2#ClientVpnEndpoint$ServerCertificateArn */ =>  {
                let var_1913 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_server_certificate_arn(var_1913);
            }
            ,
            s if s.matches("authenticationOptions") /* AuthenticationOptions com.amazonaws.ec2#ClientVpnEndpoint$AuthenticationOptions */ =>  {
                let var_1914 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_client_vpn_authentication_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_authentication_options(var_1914);
            }
            ,
            s if s.matches("connectionLogOptions") /* ConnectionLogOptions com.amazonaws.ec2#ClientVpnEndpoint$ConnectionLogOptions */ =>  {
                let var_1915 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_connection_log_response_options(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_connection_log_options(var_1915);
            }
            ,
            s if s.matches("tagSet") /* Tags com.amazonaws.ec2#ClientVpnEndpoint$Tags */ =>  {
                let var_1916 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_tag_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_tags(var_1916);
            }
            ,
            s if s.matches("securityGroupIdSet") /* SecurityGroupIds com.amazonaws.ec2#ClientVpnEndpoint$SecurityGroupIds */ =>  {
                let var_1917 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_client_vpn_security_group_id_set(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_security_group_ids(var_1917);
            }
            ,
            s if s.matches("vpcId") /* VpcId com.amazonaws.ec2#ClientVpnEndpoint$VpcId */ =>  {
                let var_1918 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_vpc_id(var_1918);
            }
            ,
            s if s.matches("selfServicePortalUrl") /* SelfServicePortalUrl com.amazonaws.ec2#ClientVpnEndpoint$SelfServicePortalUrl */ =>  {
                let var_1919 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_self_service_portal_url(var_1919);
            }
            ,
            s if s.matches("clientConnectOptions") /* ClientConnectOptions com.amazonaws.ec2#ClientVpnEndpoint$ClientConnectOptions */ =>  {
                let var_1920 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_client_connect_response_options(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_client_connect_options(var_1920);
            }
            ,
            s if s.matches("sessionTimeoutHours") /* SessionTimeoutHours com.amazonaws.ec2#ClientVpnEndpoint$SessionTimeoutHours */ =>  {
                let var_1921 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_session_timeout_hours(var_1921);
            }
            ,
            s if s.matches("clientLoginBannerOptions") /* ClientLoginBannerOptions com.amazonaws.ec2#ClientVpnEndpoint$ClientLoginBannerOptions */ =>  {
                let var_1922 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_client_login_banner_response_options(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_client_login_banner_options(var_1922);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations§

Returns a copy of the value. Read more
Performs copy-assignment from source. Read more
Formats the value using the given formatter. Read more
This method tests for self and other values to be equal, and is used by ==. Read more
This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason. Read more

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Should always be Self
The resulting type after obtaining ownership.
Creates owned data from borrowed data, usually by cloning. Read more
Uses borrowed data to replace owned data, usually by cloning. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.
Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more