Struct aws_sdk_elasticloadbalancing::model::listener::Builder

pub struct Builder { /* private fields */ }

A builder for Listener.

Implementations

impl Builder

pub fn protocol(self, input: impl Into<String>) -> Self

The load balancer transport protocol to use for routing: HTTP, HTTPS, TCP, or SSL.

pub fn set_protocol(self, input: Option<String>) -> Self

The load balancer transport protocol to use for routing: HTTP, HTTPS, TCP, or SSL.

Examples found in repository

src/xml_deser.rs (line 3212)

pub fn deser_structure_crate_model_listener(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Listener, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Listener::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Protocol") /* Protocol com.amazonaws.elasticloadbalancing#Listener$Protocol */ =>  {
                let var_112 =
                    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_protocol(var_112);
            }
            ,
            s if s.matches("LoadBalancerPort") /* LoadBalancerPort com.amazonaws.elasticloadbalancing#Listener$LoadBalancerPort */ =>  {
                let var_113 =
                    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.elasticloadbalancing#AccessPointPort`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_load_balancer_port(var_113);
            }
            ,
            s if s.matches("InstanceProtocol") /* InstanceProtocol com.amazonaws.elasticloadbalancing#Listener$InstanceProtocol */ =>  {
                let var_114 =
                    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_instance_protocol(var_114);
            }
            ,
            s if s.matches("InstancePort") /* InstancePort com.amazonaws.elasticloadbalancing#Listener$InstancePort */ =>  {
                let var_115 =
                    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.elasticloadbalancing#InstancePort`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_instance_port(var_115);
            }
            ,
            s if s.matches("SSLCertificateId") /* SSLCertificateId com.amazonaws.elasticloadbalancing#Listener$SSLCertificateId */ =>  {
                let var_116 =
                    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_ssl_certificate_id(var_116);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn load_balancer_port(self, input: i32) -> Self

The port on which the load balancer is listening. On EC2-VPC, you can specify any port from the range 1-65535. On EC2-Classic, you can specify any port from the following list: 25, 80, 443, 465, 587, 1024-65535.

pub fn set_load_balancer_port(self, input: Option<i32>) -> Self

The port on which the load balancer is listening. On EC2-VPC, you can specify any port from the range 1-65535. On EC2-Classic, you can specify any port from the following list: 25, 80, 443, 465, 587, 1024-65535.

Examples found in repository

src/xml_deser.rs (line 3227)

pub fn deser_structure_crate_model_listener(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Listener, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Listener::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Protocol") /* Protocol com.amazonaws.elasticloadbalancing#Listener$Protocol */ =>  {
                let var_112 =
                    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_protocol(var_112);
            }
            ,
            s if s.matches("LoadBalancerPort") /* LoadBalancerPort com.amazonaws.elasticloadbalancing#Listener$LoadBalancerPort */ =>  {
                let var_113 =
                    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.elasticloadbalancing#AccessPointPort`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_load_balancer_port(var_113);
            }
            ,
            s if s.matches("InstanceProtocol") /* InstanceProtocol com.amazonaws.elasticloadbalancing#Listener$InstanceProtocol */ =>  {
                let var_114 =
                    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_instance_protocol(var_114);
            }
            ,
            s if s.matches("InstancePort") /* InstancePort com.amazonaws.elasticloadbalancing#Listener$InstancePort */ =>  {
                let var_115 =
                    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.elasticloadbalancing#InstancePort`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_instance_port(var_115);
            }
            ,
            s if s.matches("SSLCertificateId") /* SSLCertificateId com.amazonaws.elasticloadbalancing#Listener$SSLCertificateId */ =>  {
                let var_116 =
                    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_ssl_certificate_id(var_116);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn instance_protocol(self, input: impl Into<String>) -> Self

The protocol to use for routing traffic to instances: HTTP, HTTPS, TCP, or SSL.

If the front-end protocol is TCP or SSL, the back-end protocol must be TCP or SSL. If the front-end protocol is HTTP or HTTPS, the back-end protocol must be HTTP or HTTPS.

If there is another listener with the same InstancePort whose InstanceProtocol is secure, (HTTPS or SSL), the listener's InstanceProtocol must also be secure.

If there is another listener with the same InstancePort whose InstanceProtocol is HTTP or TCP, the listener's InstanceProtocol must be HTTP or TCP.

pub fn set_instance_protocol(self, input: Option<String>) -> Self

The protocol to use for routing traffic to instances: HTTP, HTTPS, TCP, or SSL.

If the front-end protocol is TCP or SSL, the back-end protocol must be TCP or SSL. If the front-end protocol is HTTP or HTTPS, the back-end protocol must be HTTP or HTTPS.

If there is another listener with the same InstancePort whose InstanceProtocol is secure, (HTTPS or SSL), the listener's InstanceProtocol must also be secure.

If there is another listener with the same InstancePort whose InstanceProtocol is HTTP or TCP, the listener's InstanceProtocol must be HTTP or TCP.

Examples found in repository

src/xml_deser.rs (line 3240)

pub fn deser_structure_crate_model_listener(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Listener, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Listener::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Protocol") /* Protocol com.amazonaws.elasticloadbalancing#Listener$Protocol */ =>  {
                let var_112 =
                    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_protocol(var_112);
            }
            ,
            s if s.matches("LoadBalancerPort") /* LoadBalancerPort com.amazonaws.elasticloadbalancing#Listener$LoadBalancerPort */ =>  {
                let var_113 =
                    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.elasticloadbalancing#AccessPointPort`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_load_balancer_port(var_113);
            }
            ,
            s if s.matches("InstanceProtocol") /* InstanceProtocol com.amazonaws.elasticloadbalancing#Listener$InstanceProtocol */ =>  {
                let var_114 =
                    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_instance_protocol(var_114);
            }
            ,
            s if s.matches("InstancePort") /* InstancePort com.amazonaws.elasticloadbalancing#Listener$InstancePort */ =>  {
                let var_115 =
                    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.elasticloadbalancing#InstancePort`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_instance_port(var_115);
            }
            ,
            s if s.matches("SSLCertificateId") /* SSLCertificateId com.amazonaws.elasticloadbalancing#Listener$SSLCertificateId */ =>  {
                let var_116 =
                    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_ssl_certificate_id(var_116);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn instance_port(self, input: i32) -> Self

The port on which the instance is listening.

pub fn set_instance_port(self, input: Option<i32>) -> Self

The port on which the instance is listening.

Examples found in repository

src/xml_deser.rs (line 3255)

pub fn deser_structure_crate_model_listener(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Listener, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Listener::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Protocol") /* Protocol com.amazonaws.elasticloadbalancing#Listener$Protocol */ =>  {
                let var_112 =
                    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_protocol(var_112);
            }
            ,
            s if s.matches("LoadBalancerPort") /* LoadBalancerPort com.amazonaws.elasticloadbalancing#Listener$LoadBalancerPort */ =>  {
                let var_113 =
                    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.elasticloadbalancing#AccessPointPort`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_load_balancer_port(var_113);
            }
            ,
            s if s.matches("InstanceProtocol") /* InstanceProtocol com.amazonaws.elasticloadbalancing#Listener$InstanceProtocol */ =>  {
                let var_114 =
                    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_instance_protocol(var_114);
            }
            ,
            s if s.matches("InstancePort") /* InstancePort com.amazonaws.elasticloadbalancing#Listener$InstancePort */ =>  {
                let var_115 =
                    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.elasticloadbalancing#InstancePort`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_instance_port(var_115);
            }
            ,
            s if s.matches("SSLCertificateId") /* SSLCertificateId com.amazonaws.elasticloadbalancing#Listener$SSLCertificateId */ =>  {
                let var_116 =
                    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_ssl_certificate_id(var_116);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn ssl_certificate_id(self, input: impl Into<String>) -> Self

The Amazon Resource Name (ARN) of the server certificate.

pub fn set_ssl_certificate_id(self, input: Option<String>) -> Self

The Amazon Resource Name (ARN) of the server certificate.

Examples found in repository

src/xml_deser.rs (line 3268)

pub fn deser_structure_crate_model_listener(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Listener, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Listener::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Protocol") /* Protocol com.amazonaws.elasticloadbalancing#Listener$Protocol */ =>  {
                let var_112 =
                    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_protocol(var_112);
            }
            ,
            s if s.matches("LoadBalancerPort") /* LoadBalancerPort com.amazonaws.elasticloadbalancing#Listener$LoadBalancerPort */ =>  {
                let var_113 =
                    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.elasticloadbalancing#AccessPointPort`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_load_balancer_port(var_113);
            }
            ,
            s if s.matches("InstanceProtocol") /* InstanceProtocol com.amazonaws.elasticloadbalancing#Listener$InstanceProtocol */ =>  {
                let var_114 =
                    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_instance_protocol(var_114);
            }
            ,
            s if s.matches("InstancePort") /* InstancePort com.amazonaws.elasticloadbalancing#Listener$InstancePort */ =>  {
                let var_115 =
                    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.elasticloadbalancing#InstancePort`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_instance_port(var_115);
            }
            ,
            s if s.matches("SSLCertificateId") /* SSLCertificateId com.amazonaws.elasticloadbalancing#Listener$SSLCertificateId */ =>  {
                let var_116 =
                    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_ssl_certificate_id(var_116);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn build(self) -> Listener

Consumes the builder and constructs a Listener.

Examples found in repository

src/xml_deser.rs (line 3274)

pub fn deser_structure_crate_model_listener(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Listener, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Listener::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Protocol") /* Protocol com.amazonaws.elasticloadbalancing#Listener$Protocol */ =>  {
                let var_112 =
                    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_protocol(var_112);
            }
            ,
            s if s.matches("LoadBalancerPort") /* LoadBalancerPort com.amazonaws.elasticloadbalancing#Listener$LoadBalancerPort */ =>  {
                let var_113 =
                    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.elasticloadbalancing#AccessPointPort`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_load_balancer_port(var_113);
            }
            ,
            s if s.matches("InstanceProtocol") /* InstanceProtocol com.amazonaws.elasticloadbalancing#Listener$InstanceProtocol */ =>  {
                let var_114 =
                    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_instance_protocol(var_114);
            }
            ,
            s if s.matches("InstancePort") /* InstancePort com.amazonaws.elasticloadbalancing#Listener$InstancePort */ =>  {
                let var_115 =
                    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.elasticloadbalancing#InstancePort`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_instance_port(var_115);
            }
            ,
            s if s.matches("SSLCertificateId") /* SSLCertificateId com.amazonaws.elasticloadbalancing#Listener$SSLCertificateId */ =>  {
                let var_116 =
                    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_ssl_certificate_id(var_116);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for Builder

fn clone(&self) -> Builder

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Builder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Builder

fn default() -> Builder

Returns the “default value” for a type.

impl PartialEq<Builder> for Builder

fn eq(&self, other: &Builder) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Builder