mirror of
https://github.com/hashicorp/vault.git
synced 2025-08-21 22:51:09 +02:00
a65d9133a1
When creating database connections, there is a race condition when multiple goroutines try to create the connection at the same time. This happens, for example, on leadership changes in a cluster. Normally, the extra database connections are cleaned up when this is detected. However, some database implementations, notably Postgres, do not seem to clean up in a timely manner, and can leak in these scenarios. To fix this, we create a global lock when creating database connections to prevent multiple connections from being created at the same time. We also clean up the logic at the end so that if (somehow) we ended up creating an additional connection, we use the existing one rather than the new one. This by itself would solve our problem long-term, however, would still involve many transient database connections being created and immediately killed on leadership changes. It's not ideal to have a single global lock for database connection creation. Some potential alternatives: * a map of locks from the connection name to the lock. The biggest downside is the we probably will want to garbage collect this map so that we don't have an unbounded number of locks. * a small pool of locks, where we hash the connection names to pick the lock. Using such a pool generally is a good way to introduce deadlock, but since we will only use it in a specific case, and the purpose is to improve performance for concurrent connection creation, this is probably acceptable. Co-authored-by: Jason O'Donnell <2160810+jasonodonnell@users.noreply.github.com>
104 lines
2.4 KiB
Go
104 lines
2.4 KiB
Go
// Copyright (c) HashiCorp, Inc.
|
|
// SPDX-License-Identifier: BUSL-1.1
|
|
|
|
package syncmap
|
|
|
|
import "sync"
|
|
|
|
// SyncMap implements a map similar to sync.Map, but with generics and with an equality
|
|
// in the values specified by an "ID()" method.
|
|
type SyncMap[K comparable, V IDer] struct {
|
|
// lock is used to synchronize access to the map
|
|
lock sync.RWMutex
|
|
// data holds the actual data
|
|
data map[K]V
|
|
}
|
|
|
|
// NewSyncMap returns a new, empty SyncMap.
|
|
func NewSyncMap[K comparable, V IDer]() *SyncMap[K, V] {
|
|
return &SyncMap[K, V]{
|
|
data: make(map[K]V),
|
|
}
|
|
}
|
|
|
|
// Get returns the value for the given key.
|
|
func (m *SyncMap[K, V]) Get(k K) V {
|
|
m.lock.RLock()
|
|
defer m.lock.RUnlock()
|
|
return m.data[k]
|
|
}
|
|
|
|
// Pop deletes and returns the value for the given key, if it exists.
|
|
func (m *SyncMap[K, V]) Pop(k K) V {
|
|
m.lock.Lock()
|
|
defer m.lock.Unlock()
|
|
v, ok := m.data[k]
|
|
if ok {
|
|
delete(m.data, k)
|
|
}
|
|
return v
|
|
}
|
|
|
|
// PopIfEqual deletes and returns the value for the given key, if it exists
|
|
// and only if the ID is equal to the provided string.
|
|
func (m *SyncMap[K, V]) PopIfEqual(k K, id string) V {
|
|
m.lock.Lock()
|
|
defer m.lock.Unlock()
|
|
v, ok := m.data[k]
|
|
if ok && v.ID() == id {
|
|
delete(m.data, k)
|
|
return v
|
|
}
|
|
var zero V
|
|
return zero
|
|
}
|
|
|
|
// Put adds the given key-value pair to the map and returns the previous value, if any.
|
|
func (m *SyncMap[K, V]) Put(k K, v V) V {
|
|
m.lock.Lock()
|
|
defer m.lock.Unlock()
|
|
oldV := m.data[k]
|
|
m.data[k] = v
|
|
return oldV
|
|
}
|
|
|
|
// PutIfEmpty adds the given key-value pair to the map only if there is no value already in it,
|
|
// and returns the new value and true if so.
|
|
// If there is already a value, it returns the existing value and false.
|
|
func (m *SyncMap[K, V]) PutIfEmpty(k K, v V) (V, bool) {
|
|
m.lock.Lock()
|
|
defer m.lock.Unlock()
|
|
oldV, ok := m.data[k]
|
|
if ok {
|
|
return oldV, false
|
|
}
|
|
m.data[k] = v
|
|
return v, true
|
|
}
|
|
|
|
// Clear deletes all entries from the map, and returns the previous map.
|
|
func (m *SyncMap[K, V]) Clear() map[K]V {
|
|
m.lock.Lock()
|
|
defer m.lock.Unlock()
|
|
old := m.data
|
|
m.data = make(map[K]V)
|
|
return old
|
|
}
|
|
|
|
// Values returns a copy of all values in the map.
|
|
func (m *SyncMap[K, V]) Values() []V {
|
|
m.lock.RLock()
|
|
defer m.lock.RUnlock()
|
|
|
|
values := make([]V, 0, len(m.data))
|
|
for _, v := range m.data {
|
|
values = append(values, v)
|
|
}
|
|
return values
|
|
}
|
|
|
|
// IDer is used to extract an ID that SyncMap uses for equality checking.
|
|
type IDer interface {
|
|
ID() string
|
|
}
|