fn authorize_cache_security_group_ingress(
        &self,
        input: AuthorizeCacheSecurityGroupIngressMessage,
    ) -> RusotoFuture<
        AuthorizeCacheSecurityGroupIngressResult,
        AuthorizeCacheSecurityGroupIngressError,
    > {
        let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
        let mut params = Params::new();

        params.put("Action", "AuthorizeCacheSecurityGroupIngress");
        params.put("Version", "2015-02-02");
        AuthorizeCacheSecurityGroupIngressMessageSerializer::serialize(&mut params, "", &input);
        request.set_payload(Some(
            serde_urlencoded::to_string(&params).unwrap().into_bytes(),
        ));
        request.set_content_type("application/x-www-form-urlencoded".to_owned());

        self.client.sign_and_dispatch(request, |response| {
            if !response.status.is_success() {
                return Box::new(response.buffer().from_err().and_then(|response| {
                    Err(AuthorizeCacheSecurityGroupIngressError::from_response(
                        response,
                    ))
                }));
            }

            Box::new(response.buffer().from_err().and_then(move |response| {
                let result;

                if response.body.is_empty() {
                    result = AuthorizeCacheSecurityGroupIngressResult::default();
                } else {
                    let reader = EventReader::new_with_config(
                        response.body.as_slice(),
                        ParserConfig::new().trim_whitespace(true),
                    );
                    let mut stack = XmlResponse::new(reader.into_iter().peekable());
                    let _start_document = stack.next();
                    let actual_tag_name = peek_at_name(&mut stack)?;
                    start_element(&actual_tag_name, &mut stack)?;
                    result = AuthorizeCacheSecurityGroupIngressResultDeserializer::deserialize(
                        "AuthorizeCacheSecurityGroupIngressResult",
                        &mut stack,
                    )?;
                    skip_tree(&mut stack);
                    end_element(&actual_tag_name, &mut stack)?;
                }

                Ok(result)
            }))
        })
    }
/// <p><p>Allows network ingress to a cache security group. Applications using ElastiCache must be running on Amazon EC2, and Amazon EC2 security groups are used as the authorization mechanism.</p> <note> <p>You cannot authorize ingress from an Amazon EC2 security group in one region to an ElastiCache cluster in another region.</p> </note></p>
Allows network ingress to a cache security group. Applications using ElastiCache must be running on Amazon EC2, and Amazon EC2 security groups are used as the authorization mechanism.  You cannot authorize ingress from an Amazon EC2 security group in one region to an ElastiCache cluster in another region. 
Allows network ingress to a cache security group . Applications using ElastiCache must be running on Amazon EC2 and Amazon EC2 security groups are used as the authorization mechanism . You cannot authorize ingress from an Amazon EC2 security group in one region to an ElastiCache cluster in another region .
fn authorize_cache_security_group_ingress(
        &self,
        input: AuthorizeCacheSecurityGroupIngressMessage,
    ) -> RusotoFuture<
        AuthorizeCacheSecurityGroupIngressResult,
        AuthorizeCacheSecurityGroupIngressError,
    > {
        let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
        let mut params = Params::new();
        params.put("Action", "AuthorizeCacheSecurityGroupIngress");
        params.put("Version", "2015-02-02");
        AuthorizeCacheSecurityGroupIngressMessageSerializer::serialize(&mut params, "", &input);
        request.set_payload(Some(
            serde_urlencoded::to_string(&params).unwrap().into_bytes(),
        ));
        request.set_content_type("application/x-www-form-urlencoded".to_owned());
        self.client.sign_and_dispatch(request, |response| {
            if !response.status.is_success() {
                return Box::new(response.buffer().from_err().and_then(|response| {
                    Err(AuthorizeCacheSecurityGroupIngressError::from_response(
                        response,
                    ))
                }));
            }
            Box::new(response.buffer().from_err().and_then(move |response| {
                let result;
                if response.body.is_empty() {
                    result = AuthorizeCacheSecurityGroupIngressResult::default();
                } else {
                    let reader = EventReader::new_with_config(
                        response.body.as_slice(),
                        ParserConfig::new().trim_whitespace(true),
                    );
                    let mut stack = XmlResponse::new(reader.into_iter().peekable());
                    let _start_document = stack.next();
                    let actual_tag_name = peek_at_name(&mut stack)?;
                    start_element(&actual_tag_name, &mut stack)?;
                    result = AuthorizeCacheSecurityGroupIngressResultDeserializer::deserialize(
                        "AuthorizeCacheSecurityGroupIngressResult",
                        &mut stack,
                    )?;
                    skip_tree(&mut stack);
                    end_element(&actual_tag_name, &mut stack)?;
                }
                Ok(result)
            }))
        })
    }
fn authorize_cache_security_group_ingress ( & self , input : AuthorizeCacheSecurityGroupIngressMessage , ) -> RusotoFuture < AuthorizeCacheSecurityGroupIngressResult , AuthorizeCacheSecurityGroupIngressError , > { let mut request = SignedRequest :: new ( " " , " " , & self . region , " " ) ; let mut params = Params :: new ( ) ; params . put ( " " , " " ) ; params . put ( " " , " " ) ; AuthorizeCacheSecurityGroupIngressMessageSerializer :: serialize ( & mut params , " " , & input ) ; request . set_payload ( Some ( serde_urlencoded :: to_string ( & params ) . unwrap ( ) . into_bytes ( ) , ) ) ; request . set_content_type ( " " . to_owned ( ) ) ; self . client . sign_and_dispatch ( request , | response | { if ! response . status . is_success ( ) { return Box :: new ( response . buffer ( ) . from_err ( ) . and_then ( | response | { Err ( AuthorizeCacheSecurityGroupIngressError :: from_response ( response , ) ) } ) ) ; } Box :: new ( response . buffer ( ) . from_err ( ) . and_then ( move | response | { let result ; if response . body . is_empty ( ) { result = AuthorizeCacheSecurityGroupIngressResult :: default ( ) ; } else { let reader = EventReader :: new_with_config ( response . body . as_slice ( ) , ParserConfig :: new ( ) . trim_whitespace ( true ) , ) ; let mut stack = XmlResponse :: new ( reader . into_iter ( ) . peekable ( ) ) ; let _start_document = stack . next ( ) ; let actual_tag_name = peek_at_name ( & mut stack ) ? ; start_element ( & actual_tag_name , & mut stack ) ? ; result = AuthorizeCacheSecurityGroupIngressResultDeserializer :: deserialize ( " " , & mut stack , ) ? ; skip_tree ( & mut stack ) ; end_element ( & actual_tag_name , & mut stack ) ? ; } Ok ( result ) } ) ) } ) }
<p><p>Allows network ingress to a cache security group.
<p > <p > Allows network ingress to a cache security group .
&self
input
AuthorizeCacheSecurityGroupIngressMessage
&self
input
AuthorizeCacheSecurityGroupIngressMessage