fn reboot_cache_cluster(
        &self,
        input: RebootCacheClusterMessage,
    ) -> RusotoFuture<RebootCacheClusterResult, RebootCacheClusterError> {
        let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
        let mut params = Params::new();

        params.put("Action", "RebootCacheCluster");
        params.put("Version", "2015-02-02");
        RebootCacheClusterMessageSerializer::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(RebootCacheClusterError::from_response(response))),
                );
            }

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

                if response.body.is_empty() {
                    result = RebootCacheClusterResult::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 = RebootCacheClusterResultDeserializer::deserialize(
                        "RebootCacheClusterResult",
                        &mut stack,
                    )?;
                    skip_tree(&mut stack);
                    end_element(&actual_tag_name, &mut stack)?;
                }

                Ok(result)
            }))
        })
    }
/// <p>Reboots some, or all, of the cache nodes within a provisioned cluster. This operation applies any modified cache parameter groups to the cluster. The reboot operation takes place as soon as possible, and results in a momentary outage to the cluster. During the reboot, the cluster status is set to REBOOTING.</p> <p>The reboot causes the contents of the cache (for each cache node being rebooted) to be lost.</p> <p>When the reboot is complete, a cluster event is created.</p> <p>Rebooting a cluster is currently supported on Memcached and Redis (cluster mode disabled) clusters. Rebooting is not supported on Redis (cluster mode enabled) clusters.</p> <p>If you make changes to parameters that require a Redis (cluster mode enabled) cluster reboot for the changes to be applied, see <a href="http://docs.aws.amazon.com/AmazonElastiCache/latest/UserGuide/Clusters.Rebooting.htm">Rebooting a Cluster</a> for an alternate process.</p>
Reboots some, or all, of the cache nodes within a provisioned cluster. This operation applies any modified cache parameter groups to the cluster. The reboot operation takes place as soon as possible, and results in a momentary outage to the cluster. During the reboot, the cluster status is set to REBOOTING. The reboot causes the contents of the cache (for each cache node being rebooted) to be lost. When the reboot is complete, a cluster event is created. Rebooting a cluster is currently supported on Memcached and Redis (cluster mode disabled) clusters. Rebooting is not supported on Redis (cluster mode enabled) clusters. If you make changes to parameters that require a Redis (cluster mode enabled) cluster reboot for the changes to be applied, see Rebooting a Cluster for an alternate process.
Reboots some or all of the cache nodes within a provisioned cluster . This operation applies any modified cache parameter groups to the cluster . The reboot operation takes place as soon as possible and results in a momentary outage to the cluster . During the reboot the cluster status is set to REBOOTING . The reboot causes the contents of the cache ( for each cache node being rebooted ) to be lost . When the reboot is complete a cluster event is created . Rebooting a cluster is currently supported on Memcached and Redis ( cluster mode disabled ) clusters . Rebooting is not supported on Redis ( cluster mode enabled ) clusters . If you make changes to parameters that require a Redis ( cluster mode enabled ) cluster reboot for the changes to be applied see Rebooting a Cluster for an alternate process .
fn reboot_cache_cluster(
        &self,
        input: RebootCacheClusterMessage,
    ) -> RusotoFuture<RebootCacheClusterResult, RebootCacheClusterError> {
        let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
        let mut params = Params::new();
        params.put("Action", "RebootCacheCluster");
        params.put("Version", "2015-02-02");
        RebootCacheClusterMessageSerializer::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(RebootCacheClusterError::from_response(response))),
                );
            }
            Box::new(response.buffer().from_err().and_then(move |response| {
                let result;
                if response.body.is_empty() {
                    result = RebootCacheClusterResult::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 = RebootCacheClusterResultDeserializer::deserialize(
                        "RebootCacheClusterResult",
                        &mut stack,
                    )?;
                    skip_tree(&mut stack);
                    end_element(&actual_tag_name, &mut stack)?;
                }
                Ok(result)
            }))
        })
    }
fn reboot_cache_cluster ( & self , input : RebootCacheClusterMessage , ) -> RusotoFuture < RebootCacheClusterResult , RebootCacheClusterError > { let mut request = SignedRequest :: new ( " " , " " , & self . region , " " ) ; let mut params = Params :: new ( ) ; params . put ( " " , " " ) ; params . put ( " " , " " ) ; RebootCacheClusterMessageSerializer :: 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 ( RebootCacheClusterError :: from_response ( response ) ) ) , ) ; } Box :: new ( response . buffer ( ) . from_err ( ) . and_then ( move | response | { let result ; if response . body . is_empty ( ) { result = RebootCacheClusterResult :: 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 = RebootCacheClusterResultDeserializer :: deserialize ( " " , & mut stack , ) ? ; skip_tree ( & mut stack ) ; end_element ( & actual_tag_name , & mut stack ) ? ; } Ok ( result ) } ) ) } ) }
<p>Reboots some, or all, of the cache nodes within a provisioned cluster.
<p > Reboots some or all of the cache nodes within a provisioned cluster .
&self
input
RebootCacheClusterMessage
&self
input
RebootCacheClusterMessage