mirror of
https://github.com/opentofu/opentofu.git
synced 2024-12-30 10:47:14 -06:00
6b6b5a43c3
Because `aws_security_group_rule` resources are an abstraction on top of Security Groups, they must interact with the AWS Security Group APIs in a pattern that often results in lots of parallel requests interacting with the same security group. We've found that this pattern can trigger race conditions resulting in inconsistent behavior, including: * Rules that report as created but don't actually exist on AWS's side * Rules that show up in AWS but don't register as being created locally, resulting in follow up attempts to authorize the rule failing w/ Duplicate errors Here, we introduce a per-SG mutex that must be held by any security group before it is allowed to interact with AWS APIs. This protects the space between `DescribeSecurityGroup` and `Authorize*` / `Revoke*` calls, ensuring that no other rules interact with the SG during that span. The included test exposes the race by applying a security group with lots of rules, which based on the dependency graph can all be handled in parallel. This fails most of the time without the new locking behavior. I've omitted the mutex from `Read`, since it is only called during the Refresh walk when no changes are being made, meaning a bunch of parallel `DescribeSecurityGroup` API calls should be consistent in that case.
52 lines
1.3 KiB
Go
52 lines
1.3 KiB
Go
package mutexkv
|
|
|
|
import (
|
|
"log"
|
|
"sync"
|
|
)
|
|
|
|
// MutexKV is a simple key/value store for arbitrary mutexes. It can be used to
|
|
// serialize changes across arbitrary collaborators that share knowledge of the
|
|
// keys they must serialize on.
|
|
//
|
|
// The initial use case is to let aws_security_group_rule resources serialize
|
|
// their access to individual security groups based on SG ID.
|
|
type MutexKV struct {
|
|
lock sync.Mutex
|
|
store map[string]*sync.Mutex
|
|
}
|
|
|
|
// Locks the mutex for the given key. Caller is responsible for calling Unlock
|
|
// for the same key
|
|
func (m *MutexKV) Lock(key string) {
|
|
log.Printf("[DEBUG] Locking %q", key)
|
|
m.get(key).Lock()
|
|
log.Printf("[DEBUG] Locked %q", key)
|
|
}
|
|
|
|
// Unlock the mutex for the given key. Caller must have called Lock for the same key first
|
|
func (m *MutexKV) Unlock(key string) {
|
|
log.Printf("[DEBUG] Unlocking %q", key)
|
|
m.get(key).Unlock()
|
|
log.Printf("[DEBUG] Unlocked %q", key)
|
|
}
|
|
|
|
// Returns a mutex for the given key, no guarantee of its lock status
|
|
func (m *MutexKV) get(key string) *sync.Mutex {
|
|
m.lock.Lock()
|
|
defer m.lock.Unlock()
|
|
mutex, ok := m.store[key]
|
|
if !ok {
|
|
mutex = &sync.Mutex{}
|
|
m.store[key] = mutex
|
|
}
|
|
return mutex
|
|
}
|
|
|
|
// Returns a properly initalized MutexKV
|
|
func NewMutexKV() *MutexKV {
|
|
return &MutexKV{
|
|
store: make(map[string]*sync.Mutex),
|
|
}
|
|
}
|