> (you don't have to strictly follow this form)

**Use case**

Sometimes, for really sophisticated scenarios it can be hard to control the amount of in-progress backups run externally. For the purpose of simpler control we can introduce server-level setting which disallows running concurrent backups of any type. 

Something like this in `config.xml` (enabled by default):
`<allow_concurrent_backups>true</allow_concurrent_backups>`

**Describe the solution you'd like**

It's important that backups can be executed in distributed way on multiple servers. Need to take it into account.

**Describe alternatives you've considered**
External check of `system.backups` table, but it can be complex.

{
    
    progress_callback = callback;
}
ProgressCallback Context::getProgressCallback() const
{
    return progress_callback;
}
void Context::setProcessListElement(QueryStatusPtr elem)
{
    
    process_list_elem = elem;
    has_process_list_elem = elem.get();
}
QueryStatusPtr Context::getProcessListElement() const
{
    if (!has_process_list_elem)
        return {};
    if (auto res = process_list_elem.lock())
        return res;
    throw Exception(ErrorCodes::LOGICAL_ERROR, "Weak pointer to process_list_elem expired during query execution, it's a bug");
}
void Context::setUncompressedCache(size_t max_size_in_bytes, const String & uncompressed_cache_policy)
{
    auto lock = getLock();
    if (shared->uncompressed_cache)
        throw Exception("Uncompressed cache has been already created.", ErrorCodes::LOGICAL_ERROR);
    shared->uncompressed_cache = std::make_shared<UncompressedCache>(max_size_in_bytes, uncompressed_cache_policy);
}
UncompressedCachePtr Context::getUncompressedCache() const