mirror of
https://github.com/turbot/steampipe.git
synced 2026-04-11 16:00:03 -04:00
43dd6c7a61
If plugin process crashes, benchmark or dashboard runs can leave running plugin processes after shutdown. Fixes #3598
109 lines
3.3 KiB
Go
109 lines
3.3 KiB
Go
package modconfig
|
|
|
|
import (
|
|
"strings"
|
|
|
|
"github.com/turbot/steampipe/pkg/type_conversion"
|
|
"github.com/turbot/steampipe/pkg/utils"
|
|
)
|
|
|
|
// ModVariableMap is a struct containins maps of variable definitions
|
|
type ModVariableMap struct {
|
|
// which mod have these variables been loaded for?
|
|
Mod *Mod
|
|
// top level variables
|
|
RootVariables map[string]*Variable
|
|
// map of dependency variable maps, keyed by dependency NAME
|
|
DependencyVariables map[string]*ModVariableMap
|
|
|
|
// a list of the pointers to the variables whose values can be changed
|
|
// NOTE: this refers to the SAME variable objects as exist in the RootVariables and DependencyVariables maps,
|
|
// so when we set the value of public variables, we mutate the underlying variable
|
|
PublicVariables map[string]*Variable
|
|
}
|
|
|
|
// NewModVariableMap builds a ModVariableMap using the variables from a mod and its dependencies
|
|
func NewModVariableMap(mod *Mod) *ModVariableMap {
|
|
m := &ModVariableMap{
|
|
Mod: mod,
|
|
RootVariables: make(map[string]*Variable),
|
|
DependencyVariables: make(map[string]*ModVariableMap),
|
|
}
|
|
|
|
// add variables into map, modifying the key to be the variable short name
|
|
for k, v := range mod.ResourceMaps.Variables {
|
|
m.RootVariables[buildVariableMapKey(k)] = v
|
|
}
|
|
|
|
// now traverse all dependency mods
|
|
for _, depMod := range mod.ResourceMaps.Mods {
|
|
// todo for some reason the mod appears in its own resource maps?
|
|
if depMod.Name() != mod.Name() {
|
|
m.DependencyVariables[depMod.DependencyName] = NewModVariableMap(depMod)
|
|
}
|
|
}
|
|
|
|
// build map of all publicy settable variables
|
|
m.PopulatePublicVariables()
|
|
|
|
return m
|
|
}
|
|
|
|
func (m *ModVariableMap) ToArray() []*Variable {
|
|
var res []*Variable
|
|
|
|
keys := utils.SortedMapKeys(m.RootVariables)
|
|
for _, k := range keys {
|
|
res = append(res, m.RootVariables[k])
|
|
}
|
|
|
|
for _, depVariables := range m.DependencyVariables {
|
|
|
|
keys := utils.SortedMapKeys(depVariables.RootVariables)
|
|
for _, k := range keys {
|
|
res = append(res, depVariables.RootVariables[k])
|
|
}
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
// build map key fopr root variables - they are keyed by short name
|
|
// to allow the user to set their value using the short name
|
|
func buildVariableMapKey(k string) string {
|
|
name := strings.TrimPrefix(k, "var.")
|
|
return name
|
|
}
|
|
|
|
// PopulatePublicVariables builds a map of top level and dependency variables
|
|
// (dependency variables are keyed by full (qualified) name
|
|
func (m *ModVariableMap) PopulatePublicVariables() {
|
|
res := make(map[string]*Variable)
|
|
for k, v := range m.RootVariables {
|
|
// add top level vars keyed by short name
|
|
res[k] = v
|
|
}
|
|
// copy ROOT variables for each top level dependency
|
|
for _, depVars := range m.DependencyVariables {
|
|
for _, v := range depVars.RootVariables {
|
|
// add dependency vars keyed by full name
|
|
res[v.FullName] = v
|
|
}
|
|
}
|
|
m.PublicVariables = res
|
|
}
|
|
|
|
// GetPublicVariableValues converts public variables into a map of string variable values
|
|
func (m *ModVariableMap) GetPublicVariableValues() (map[string]string, error) {
|
|
res := make(map[string]string, len(m.PublicVariables))
|
|
for k, v := range m.PublicVariables {
|
|
// TODO investigate workspace usage of value string and determine whether we can simply format ValueGo
|
|
valueString, err := type_conversion.CtyToString(v.Value)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
res[k] = valueString
|
|
}
|
|
return res, nil
|
|
}
|