github.com/tilt-dev/tilt@v0.33.15-0.20240515162809-0a22ed45d8a0/internal/tiltfile/updatesettings/update_settings.go (about)

     1  package updatesettings
     2  
     3  import (
     4  	"fmt"
     5  	"time"
     6  
     7  	"github.com/pkg/errors"
     8  	"go.starlark.net/starlark"
     9  
    10  	"github.com/tilt-dev/tilt/pkg/model"
    11  
    12  	"github.com/tilt-dev/tilt/internal/tiltfile/starkit"
    13  	"github.com/tilt-dev/tilt/internal/tiltfile/value"
    14  )
    15  
    16  // Implements functions for dealing with update settings.
    17  type Plugin struct{}
    18  
    19  func NewPlugin() Plugin {
    20  	return Plugin{}
    21  }
    22  
    23  func (e Plugin) NewState() interface{} {
    24  	return model.DefaultUpdateSettings()
    25  }
    26  
    27  func (e Plugin) OnStart(env *starkit.Environment) error {
    28  	return env.AddBuiltin("update_settings", e.updateSettings)
    29  }
    30  
    31  func (e *Plugin) updateSettings(thread *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    32  	var maxParallelUpdates, k8sUpsertTimeoutSecs starlark.Value
    33  	var unusedImageWarnings value.StringOrStringList
    34  	if err := starkit.UnpackArgs(thread, fn.Name(), args, kwargs,
    35  		"max_parallel_updates?", &maxParallelUpdates,
    36  		"k8s_upsert_timeout_secs?", &k8sUpsertTimeoutSecs,
    37  		"suppress_unused_image_warnings?", &unusedImageWarnings); err != nil {
    38  		return nil, err
    39  	}
    40  
    41  	mpu, mpuPassed, err := valueToInt(maxParallelUpdates)
    42  	if err != nil {
    43  		return nil, errors.Wrap(err, "update_settings: for parameter \"max_parallel_updates\"")
    44  	}
    45  	if mpuPassed && mpu < 1 {
    46  		return nil, fmt.Errorf("max number of parallel updates must be >= 1(got: %d)",
    47  			maxParallelUpdates)
    48  	}
    49  
    50  	kuts, kutsPassed, err := valueToInt(k8sUpsertTimeoutSecs)
    51  	if err != nil {
    52  		return nil, errors.Wrap(err, "update_settings: for parameter \"k8s_upsert_timeout_secs\"")
    53  	}
    54  	if kutsPassed && kuts < 1 {
    55  		return nil, fmt.Errorf("minimum k8s upsert timeout is 1s; got %ds",
    56  			k8sUpsertTimeoutSecs)
    57  	}
    58  
    59  	err = starkit.SetState(thread, func(settings model.UpdateSettings) model.UpdateSettings {
    60  		if mpuPassed {
    61  			settings = settings.WithMaxParallelUpdates(mpu)
    62  		}
    63  		if kutsPassed {
    64  			settings = settings.WithK8sUpsertTimeout(time.Duration(kuts) * time.Second)
    65  		}
    66  		settings.SuppressUnusedImageWarnings = append(settings.SuppressUnusedImageWarnings, unusedImageWarnings.Values...)
    67  		return settings
    68  	})
    69  
    70  	return starlark.None, err
    71  }
    72  
    73  func valueToInt(v starlark.Value) (val int, wasPassed bool, err error) {
    74  	switch x := v.(type) {
    75  	case nil, starlark.NoneType:
    76  		return 0, false, nil
    77  	case starlark.Int:
    78  		val, err := starlark.AsInt32(x)
    79  		return val, true, err
    80  	default:
    81  		return 0, true, fmt.Errorf("got %T, want int", x)
    82  	}
    83  }
    84  
    85  var _ starkit.StatefulPlugin = Plugin{}
    86  
    87  func MustState(model starkit.Model) model.UpdateSettings {
    88  	state, err := GetState(model)
    89  	if err != nil {
    90  		panic(err)
    91  	}
    92  	return state
    93  }
    94  
    95  func GetState(m starkit.Model) (model.UpdateSettings, error) {
    96  	var state model.UpdateSettings
    97  	err := m.Load(&state)
    98  	return state, err
    99  }