github.com/lyraproj/hiera@v1.0.0-rc4/session/resolvedconfig.go (about)

     1  package session
     2  
     3  import (
     4  	"strings"
     5  
     6  	"github.com/lyraproj/dgo/dgo"
     7  	"github.com/lyraproj/hiera/api"
     8  	"github.com/lyraproj/hiera/internal"
     9  	"github.com/lyraproj/hiera/merge"
    10  )
    11  
    12  type (
    13  	resolvedConfig struct {
    14  		cfg              api.Config
    15  		providers        []api.DataProvider
    16  		defaultProviders []api.DataProvider
    17  		lookupOptions    dgo.Map
    18  		moduleName       string
    19  	}
    20  )
    21  
    22  // CreateProvider creates and returns the DataProvider configured by the given entry
    23  func CreateProvider(e api.Entry) api.DataProvider {
    24  	switch e.Function().Kind() {
    25  	case api.KindDataHash:
    26  		return internal.NewDataHashProvider(e)
    27  	case api.KindDataDig:
    28  		return internal.NewDataDigProvider(e)
    29  	default:
    30  		return internal.NewLookupKeyProvider(e)
    31  	}
    32  }
    33  
    34  // Resolve resolves the given Config into a ResolvedConfig. Resolving means creating the proper
    35  // DataProviders for all Hierarchy entries
    36  func Resolve(ic api.Invocation, hc api.Config, moduleName string) api.ResolvedConfig {
    37  	r := &resolvedConfig{cfg: hc, moduleName: moduleName}
    38  	r.Resolve(ic)
    39  	return r
    40  }
    41  
    42  func (r *resolvedConfig) Config() api.Config {
    43  	return r.cfg
    44  }
    45  
    46  func (r *resolvedConfig) Hierarchy() []api.DataProvider {
    47  	return r.providers
    48  }
    49  
    50  func (r *resolvedConfig) DefaultHierarchy() []api.DataProvider {
    51  	return r.defaultProviders
    52  }
    53  
    54  func (r *resolvedConfig) LookupOptions(key api.Key) dgo.Map {
    55  	root := key.Root()
    56  	if r.lookupOptions != nil && (r.moduleName == `` || strings.HasPrefix(root, r.moduleName+`::`)) {
    57  		if m, ok := r.lookupOptions.Get(root).(dgo.Map); ok {
    58  			return m
    59  		}
    60  	}
    61  	return nil
    62  }
    63  
    64  func (r *resolvedConfig) Resolve(ic api.Invocation) {
    65  	icc := ic.ForConfig()
    66  	r.providers = r.CreateProviders(icc, r.cfg.Hierarchy())
    67  	r.defaultProviders = r.CreateProviders(icc, r.cfg.DefaultHierarchy())
    68  
    69  	ms := merge.GetStrategy(`deep`, nil)
    70  	k := api.NewKey(`lookup_options`)
    71  	lic := ic.ForLookupOptions()
    72  	v := lic.WithLookup(k, func() dgo.Value {
    73  		return ms.MergeLookup(r.Hierarchy(), lic, func(prv interface{}) dgo.Value {
    74  			pr := prv.(api.DataProvider)
    75  			return lic.MergeLocations(k, pr, ms)
    76  		})
    77  	})
    78  
    79  	if lm, ok := v.(dgo.Map); ok {
    80  		r.lookupOptions = lm
    81  	}
    82  }
    83  
    84  func (r *resolvedConfig) CreateProviders(ic api.Invocation, hierarchy []api.Entry) []api.DataProvider {
    85  	providers := make([]api.DataProvider, len(hierarchy))
    86  	defaults := r.cfg.Defaults().Resolve(ic, nil)
    87  	for i, he := range hierarchy {
    88  		providers[i] = CreateProvider(he.Resolve(ic, defaults))
    89  	}
    90  	return providers
    91  }