modify_global_replication_group async ¶

async def modify_global_replication_group(
    self,
    *,
    config_overrides: Optional[AsyncElastiCacheClientConfig] = None,
    global_replication_group_id: Optional[
        "capo_elasticache.types.string.String"
    ] = None,
    apply_immediately: Optional["capo_elasticache.types.boolean.Boolean"] = None,
    cache_node_type: Optional["capo_elasticache.types.string.String"] = None,
    engine: Optional["capo_elasticache.types.string.String"] = None,
    engine_version: Optional["capo_elasticache.types.string.String"] = None,
    cache_parameter_group_name: Optional[
        "capo_elasticache.types.string.String"
    ] = None,
    global_replication_group_description: Optional[
        "capo_elasticache.types.string.String"
    ] = None,
    automatic_failover_enabled: Optional[
        "capo_elasticache.types.boolean_optional.BooleanOptional"
    ] = None,
) -> "capo_elasticache.types.modify_global_replication_group_result.ModifyGlobalReplicationGroupResult":
    """<p>Modifies the settings for a Global datastore.</p>

    Args:
        global_replication_group_id: <p>The name of the Global datastore</p>
        apply_immediately: <p>This parameter causes the modifications in this request and any pending modifications to be applied, asynchronously and as soon as possible. Modifications to Global Replication Groups cannot be requested to be applied in PreferredMaintenceWindow. </p>
        cache_node_type: <p>A valid cache node type that you want to scale this Global datastore to.</p>
        engine: <p>Modifies the engine listed in a global replication group message. The options are valkey, memcached or redis.</p>
        engine_version: <p>The upgraded version of the cache engine to be run on the clusters in the Global datastore. </p>
        cache_parameter_group_name: <p>The name of the cache parameter group to use with the Global datastore. It must be compatible with the major engine version used by the Global datastore.</p>
        global_replication_group_description: <p>A description of the Global datastore</p>
        automatic_failover_enabled: <p>Determines whether a read replica is automatically promoted to read/write primary if the existing primary encounters a failure. </p>

    Raises:
        capo_elasticache.errors.global_replication_group_not_found_fault.GlobalReplicationGroupNotFoundFault: <p>The Global datastore does not exist</p>
        capo_elasticache.errors.invalid_global_replication_group_state_fault.InvalidGlobalReplicationGroupStateFault: <p>The Global datastore is not available or in primary-only state.</p>
        capo_elasticache.errors.invalid_parameter_value_exception.InvalidParameterValueException: <p>The value for a parameter is invalid.</p>
        capo_elasticache.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_elasticache.types.modify_global_replication_group_message.ModifyGlobalReplicationGroupMessage]",
    ) -> AsyncOperationResponse[
        "capo_elasticache.types.modify_global_replication_group_result.ModifyGlobalReplicationGroupResult"
    ]:
        import capo_elasticache._operations.amazon_elasti_cache_v9.modify_global_replication_group

        (
            output,
            http_response,
        ) = await capo_elasticache._operations.amazon_elasti_cache_v9.modify_global_replication_group.async_modify_global_replication_group(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("ModifyGlobalReplicationGroup")
    )
    input_: capo_elasticache.types.modify_global_replication_group_message.ModifyGlobalReplicationGroupMessage = {}
    if global_replication_group_id is not None:
        input_["global_replication_group_id"] = global_replication_group_id
    if apply_immediately is not None:
        input_["apply_immediately"] = apply_immediately
    if cache_node_type is not None:
        input_["cache_node_type"] = cache_node_type
    if engine is not None:
        input_["engine"] = engine
    if engine_version is not None:
        input_["engine_version"] = engine_version
    if cache_parameter_group_name is not None:
        input_["cache_parameter_group_name"] = cache_parameter_group_name
    if global_replication_group_description is not None:
        input_["global_replication_group_description"] = (
            global_replication_group_description
        )
    if automatic_failover_enabled is not None:
        input_["automatic_failover_enabled"] = automatic_failover_enabled

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output