github.com/grahambrereton-form3/tilt@v0.10.18/internal/tiltfile/k8scontext/k8scontext.go (about)

     1  package k8scontext
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"go.starlark.net/starlark"
     7  
     8  	"github.com/windmilleng/tilt/internal/k8s"
     9  	"github.com/windmilleng/tilt/internal/tiltfile/starkit"
    10  	"github.com/windmilleng/tilt/internal/tiltfile/value"
    11  )
    12  
    13  // Implements functions for dealing with the Kubernetes context.
    14  // Exposes an API for other plugins to get and validate the allowed k8s context.
    15  type Extension struct {
    16  	context k8s.KubeContext
    17  	env     k8s.Env
    18  }
    19  
    20  func NewExtension(context k8s.KubeContext, env k8s.Env) Extension {
    21  	return Extension{
    22  		context: context,
    23  		env:     env,
    24  	}
    25  }
    26  
    27  func (e Extension) NewState() interface{} {
    28  	return State{context: e.context, env: e.env}
    29  }
    30  
    31  func (e Extension) OnStart(env *starkit.Environment) error {
    32  	err := env.AddBuiltin("allow_k8s_contexts", e.allowK8sContexts)
    33  	if err != nil {
    34  		return err
    35  	}
    36  
    37  	err = env.AddBuiltin("k8s_context", e.k8sContext)
    38  	if err != nil {
    39  		return err
    40  	}
    41  	return nil
    42  }
    43  
    44  func (e Extension) k8sContext(thread *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    45  	return starlark.String(e.context), nil
    46  }
    47  
    48  func (e Extension) allowK8sContexts(thread *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    49  	var contexts starlark.Value
    50  	if err := starkit.UnpackArgs(thread, fn.Name(), args, kwargs,
    51  		"contexts", &contexts,
    52  	); err != nil {
    53  		return nil, err
    54  	}
    55  
    56  	newContexts := []k8s.KubeContext{}
    57  	for _, c := range value.ValueOrSequenceToSlice(contexts) {
    58  		switch val := c.(type) {
    59  		case starlark.String:
    60  			newContexts = append(newContexts, k8s.KubeContext(val))
    61  		default:
    62  			return nil, fmt.Errorf("allow_k8s_contexts contexts must be a string or a sequence of strings; found a %T", val)
    63  
    64  		}
    65  	}
    66  
    67  	err := starkit.SetState(thread, func(existing State) State {
    68  		return State{
    69  			context: existing.context,
    70  			env:     existing.env,
    71  			allowed: append(newContexts, existing.allowed...),
    72  		}
    73  	})
    74  
    75  	return starlark.None, err
    76  }
    77  
    78  var _ starkit.StatefulExtension = &Extension{}
    79  
    80  type State struct {
    81  	context k8s.KubeContext
    82  	env     k8s.Env
    83  	allowed []k8s.KubeContext
    84  }
    85  
    86  func (s State) KubeContext() k8s.KubeContext {
    87  	return s.context
    88  }
    89  
    90  func (s State) IsAllowed() bool {
    91  	if s.env == k8s.EnvNone || s.env.IsLocalCluster() {
    92  		return true
    93  	}
    94  
    95  	for _, c := range s.allowed {
    96  		if c == s.context {
    97  			return true
    98  		}
    99  	}
   100  
   101  	return false
   102  }
   103  
   104  func MustState(model starkit.Model) State {
   105  	state, err := GetState(model)
   106  	if err != nil {
   107  		panic(err)
   108  	}
   109  	return state
   110  }
   111  
   112  func GetState(model starkit.Model) (State, error) {
   113  	var state State
   114  	err := model.Load(&state)
   115  	return state, err
   116  }