mirror of
https://github.com/opentofu/opentofu.git
synced 2024-12-28 01:41:48 -06:00
0b14c2cdb3
Previously the logic for inferring a provider type from a resource name was buried a utility function in the 'terraform' package. Instead here we lift it up into the 'config' package where we can make broader use of it and where it's easier to discover.
82 lines
1.7 KiB
Go
82 lines
1.7 KiB
Go
package terraform
|
|
|
|
import (
|
|
"sort"
|
|
|
|
"github.com/hashicorp/terraform/config"
|
|
)
|
|
|
|
// Semaphore is a wrapper around a channel to provide
|
|
// utility methods to clarify that we are treating the
|
|
// channel as a semaphore
|
|
type Semaphore chan struct{}
|
|
|
|
// NewSemaphore creates a semaphore that allows up
|
|
// to a given limit of simultaneous acquisitions
|
|
func NewSemaphore(n int) Semaphore {
|
|
if n == 0 {
|
|
panic("semaphore with limit 0")
|
|
}
|
|
ch := make(chan struct{}, n)
|
|
return Semaphore(ch)
|
|
}
|
|
|
|
// Acquire is used to acquire an available slot.
|
|
// Blocks until available.
|
|
func (s Semaphore) Acquire() {
|
|
s <- struct{}{}
|
|
}
|
|
|
|
// TryAcquire is used to do a non-blocking acquire.
|
|
// Returns a bool indicating success
|
|
func (s Semaphore) TryAcquire() bool {
|
|
select {
|
|
case s <- struct{}{}:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Release is used to return a slot. Acquire must
|
|
// be called as a pre-condition.
|
|
func (s Semaphore) Release() {
|
|
select {
|
|
case <-s:
|
|
default:
|
|
panic("release without an acquire")
|
|
}
|
|
}
|
|
|
|
func resourceProvider(resourceType, explicitProvider string) string {
|
|
return config.ResourceProviderFullName(resourceType, explicitProvider)
|
|
}
|
|
|
|
// strSliceContains checks if a given string is contained in a slice
|
|
// When anybody asks why Go needs generics, here you go.
|
|
func strSliceContains(haystack []string, needle string) bool {
|
|
for _, s := range haystack {
|
|
if s == needle {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// deduplicate a slice of strings
|
|
func uniqueStrings(s []string) []string {
|
|
if len(s) < 2 {
|
|
return s
|
|
}
|
|
|
|
sort.Strings(s)
|
|
result := make([]string, 1, len(s))
|
|
result[0] = s[0]
|
|
for i := 1; i < len(s); i++ {
|
|
if s[i] != result[len(result)-1] {
|
|
result = append(result, s[i])
|
|
}
|
|
}
|
|
return result
|
|
}
|