tiltfile

Documentation

Index

• Constants
• Variables
• func DecideRegistry(ctx context.Context, kCli k8s.Client, tlr *tiltfile.TiltfileLoadResult) container.Registry
• func HandleConfigsReloadStarted(ctx context.Context, state *store.EngineState, ...)
• func HandleConfigsReloaded(ctx context.Context, state *store.EngineState, event ConfigsReloadedAction)
• func SpanIDForLoadCount(mn model.ManifestName, loadCount int) logstore.SpanID
• func ToFileWatchObjects(watchInputs WatchInputs, ...) apiset.TypedObjectSet
• type BuildEntry
  • func (be *BuildEntry) WithLogger(ctx context.Context, st store.RStore) context.Context
• type ConfigsReloadStartedAction
  • func (ConfigsReloadStartedAction) Action()
• type ConfigsReloadedAction
  • func (ConfigsReloadedAction) Action()
• type Reconciler
  • func NewReconciler(st store.RStore, tfl tiltfile.TiltfileLoader, k8sClient k8s.Client, ...) *Reconciler
  • func (r *Reconciler) CreateBuilder(mgr ctrl.Manager) (*builder.Builder, error)
  • func (r *Reconciler) Reconcile(ctx context.Context, request reconcile.Request) (reconcile.Result, error)
• type WatchInputs
• type WatchableTarget

Constants

const TiltfileBuildSource = "tiltfile"

Variables

var WireSet = wire.NewSet(
	NewReconciler,
)

Functions

func DecideRegistry

func DecideRegistry(ctx context.Context, kCli k8s.Client, tlr *tiltfile.TiltfileLoadResult) container.Registry

DecideRegistry returns the image registry we should use; if detected, a pre-configured local registry; otherwise, the registry specified by the user via default_registry. Otherwise, we'll return the zero value of `s.defaultReg`, which is an empty registry. It has side-effects (a log line) and so should only be called once.

func HandleConfigsReloadStarted

func HandleConfigsReloadStarted(
	ctx context.Context,
	state *store.EngineState,
	event ConfigsReloadStartedAction,
)

func HandleConfigsReloaded

func HandleConfigsReloaded(
	ctx context.Context,
	state *store.EngineState,
	event ConfigsReloadedAction,
)

In the original Tilt architecture, the Tiltfile contained the whole engine state. Reloading the tiltfile re-created that state from scratch.

We've moved towards a more modular architecture, but many of the tilt data models aren't modular. For example, if two Tiltfiles set UpdateSettings, it's not clear which one "wins" or how their preferences combine.

In the long-term, Tiltfile settings should only take affect in objects created by that Tiltfile. (e.g., WatchSettings only affects FileWatches created by that Tiltfile.)

In the medium-term, we resolve this in the EngineState in three different ways:

1. If a data structure supports merging (like the Manifest map), do a merge.
2. If merging fails (like if two Tiltfiles define the same Manifest), log an Error and try to do something resonable.
3. If a data structure does not support merging (like UpdateSettings), only accept that data structure from the "main" tiltfile.

func SpanIDForLoadCount

func SpanIDForLoadCount(mn model.ManifestName, loadCount int) logstore.SpanID

func ToFileWatchObjects

func ToFileWatchObjects(watchInputs WatchInputs, disableSources map[model.ManifestName]*v1alpha1.DisableSource) apiset.TypedObjectSet

FileWatchesFromManifests creates FileWatch specs from Tilt manifests in the engine state.

Types

type BuildEntry

type BuildEntry struct {
	Name                  model.ManifestName
	FilesChanged          []string
	BuildReason           model.BuildReason
	Args                  []string
	TiltfilePath          string
	CheckpointAtExecStart logstore.Checkpoint
	LoadCount             int
	ArgsChanged           bool
}

BuildEntry is vestigial, but currently used to help manage state about a tiltfile build.

func (*BuildEntry) WithLogger

func (be *BuildEntry) WithLogger(ctx context.Context, st store.RStore) context.Context

type ConfigsReloadStartedAction

type ConfigsReloadStartedAction struct {
	Name         model.ManifestName
	FilesChanged []string
	StartTime    time.Time
	SpanID       logstore.SpanID
	Reason       model.BuildReason
}

func (ConfigsReloadStartedAction) Action

func (ConfigsReloadStartedAction) Action()

type ConfigsReloadedAction

type ConfigsReloadedAction struct {
	Name model.ManifestName

	// TODO(nick): Embed TiltfileLoadResult instead of copying fields.
	Manifests   []model.Manifest
	Tiltignore  model.Dockerignore
	ConfigFiles []string

	FinishTime           time.Time
	Err                  error
	Warnings             []string
	Features             map[string]bool
	TeamID               string
	TelemetrySettings    model.TelemetrySettings
	Secrets              model.SecretSet
	DockerPruneSettings  model.DockerPruneSettings
	AnalyticsTiltfileOpt analytics.Opt
	VersionSettings      model.VersionSettings
	UpdateSettings       model.UpdateSettings
	WatchSettings        model.WatchSettings

	// A checkpoint into the logstore when Tiltfile execution started.
	// Useful for knowing how far back in time we have to scrub secrets.
	CheckpointAtExecStart logstore.Checkpoint
}

func (ConfigsReloadedAction) Action

func (ConfigsReloadedAction) Action()

type Reconciler

type Reconciler struct {
	// contains filtered or unexported fields
}

func NewReconciler

func NewReconciler(st store.RStore, tfl tiltfile.TiltfileLoader, k8sClient k8s.Client, dockerClient docker.Client,
	ctrlClient ctrlclient.Client, scheme *runtime.Scheme,
	engineMode store.EngineMode,
	k8sContextOverride k8s.KubeContextOverride,
	k8sNamespaceOverride k8s.NamespaceOverride) *Reconciler

func (*Reconciler) CreateBuilder

func (r *Reconciler) CreateBuilder(mgr ctrl.Manager) (*builder.Builder, error)

func (*Reconciler) Reconcile

func (r *Reconciler) Reconcile(ctx context.Context, request reconcile.Request) (reconcile.Result, error)

Reconcile manages Tiltfile execution.

type WatchInputs

type WatchInputs struct {
	TiltfileManifestName model.ManifestName
	TiltfilePath         string
	Manifests            []model.Manifest
	ConfigFiles          []string
	WatchSettings        model.WatchSettings
	Tiltignore           model.Dockerignore
	EngineMode           store.EngineMode
}

type WatchableTarget

type WatchableTarget interface {
	ignore.IgnorableTarget
	Dependencies() []string
	ID() model.TargetID
}