webview: add buildResult.BuildType to webview proto [ch4520]

internal/hud/webview/convert.go

@@ -91,6 +91,11 @@ func StateToProtoView(s store.EngineState, logCheckpoint logstore.Checkpoint) (*
 			return nil, err
 		}
 
+		specs, err := TargetSpecsToProto(mt.Manifest.TargetSpecs())
+		if err != nil {
+			return nil, err
+		}
+
 		// NOTE(nick): Right now, the UX is designed to show the output exactly one
 		// pod. A better UI might summarize the pods in other ways (e.g., show the
 		// "most interesting" pod that's crash looping, or show logs from all pods
@@ -113,6 +118,7 @@ func StateToProtoView(s store.EngineState, logCheckpoint logstore.Checkpoint) (*
 			CurrentBuild:       cb,
 			Endpoints:          endpoints,
 			PodID:              podID.String(),
+			Specs:              specs,
 			ShowBuildStatus:    len(mt.Manifest.ImageTargets) > 0 || mt.Manifest.IsDC(),
 			CrashLog:           ms.CrashLog.String(),
 			TriggerMode:        int32(mt.Manifest.TriggerMode),

internal/hud/webview/convert_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/golang/protobuf/ptypes/timestamp"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -205,8 +206,108 @@ func TestLocalResource(t *testing.T) {
 	r := v.Resources[1]
 	assert.Equal(t, "test", r.Name)
 	assert.Equal(t, model.RuntimeStatusNotApplicable, model.RuntimeStatus(r.RuntimeStatus))
+	require.Len(t, r.Specs, 1)
+	spec := r.Specs[0]
+	require.Equal(t, proto_webview.TargetType_TARGET_TYPE_LOCAL, spec.Type)
+	require.False(t, spec.HasLiveUpdate)
 }
 
+func TestBuildHistory(t *testing.T) {
+	br1 := model.BuildRecord{
+		StartTime:  time.Now().Add(-1 * time.Hour),
+		FinishTime: time.Now().Add(-50 * time.Minute),
+		Reason:     model.BuildReasonFlagInit,
+		BuildTypes: []model.BuildType{model.BuildTypeImage, model.BuildTypeK8s},
+	}
+	br2 := model.BuildRecord{
+		Edits:      []string{"a.txt", "b.txt"},
+		StartTime:  time.Now().Add(-45 * time.Minute),
+		FinishTime: time.Now().Add(-44 * time.Minute),
+		Reason:     model.BuildReasonFlagChangedFiles,
+		BuildTypes: []model.BuildType{model.BuildTypeLiveUpdate},
+	}
+	br3 := model.BuildRecord{
+		StartTime:  time.Now().Add(-20 * time.Minute),
+		FinishTime: time.Now().Add(-19 * time.Minute),
+		Reason:     model.BuildReasonFlagCrash,
+		BuildTypes: []model.BuildType{model.BuildTypeImage, model.BuildTypeK8s},
+	}
+	buildRecords := []model.BuildRecord{br1, br2, br3}
+	expectedUpdateTypes := [][]proto_webview.UpdateType{
+		[]proto_webview.UpdateType{proto_webview.UpdateType_UPDATE_TYPE_IMAGE, proto_webview.UpdateType_UPDATE_TYPE_K8S},
+		[]proto_webview.UpdateType{proto_webview.UpdateType_UPDATE_TYPE_LIVE_UPDATE},
+		[]proto_webview.UpdateType{proto_webview.UpdateType_UPDATE_TYPE_IMAGE, proto_webview.UpdateType_UPDATE_TYPE_K8S},
+	}
+
+	m := model.Manifest{Name: "foo"}.WithDeployTarget(model.K8sTarget{})
+	state := newState([]model.Manifest{m})
+	state.ManifestTargets[m.Name].State.BuildHistory = buildRecords
+
+	v := stateToProtoView(t, *state)
+	require.Equal(t, 2, len(v.Resources))
+	r := v.Resources[1]
+	require.Equal(t, "foo", r.Name)
+	require.Len(t, r.BuildHistory, 3)
+
+	for i, actual := range r.BuildHistory {
+		expected := buildRecords[i]
+		require.Equal(t, expected.Edits, actual.Edits)
+		require.Equal(t, mustTimeToProto(expected.StartTime), actual.StartTime)
+		require.Equal(t, mustTimeToProto(expected.FinishTime), actual.FinishTime)
+		require.Equal(t, i == 2, actual.IsCrashRebuild)
+		require.ElementsMatch(t, expectedUpdateTypes[i], actual.UpdateTypes)
+	}
+}
+
+func TestSpecs(t *testing.T) {
+	lu, err := model.NewLiveUpdate(
+		[]model.LiveUpdateStep{model.LiveUpdateSyncStep{Source: "foo", Dest: "bar"}}, ".")
+	require.NoError(t, err)
+	luTarg := model.ImageTarget{}.WithBuildDetails(model.DockerBuild{LiveUpdate: lu})
+
+	mNoLiveUpd := model.Manifest{Name: "noLiveUpd"}.WithImageTarget(model.ImageTarget{}).WithDeployTarget(model.K8sTarget{})
+	mLiveUpd := model.Manifest{Name: "liveUpd"}.WithImageTarget(luTarg).WithDeployTarget(model.K8sTarget{})
+	mLocal := model.Manifest{Name: "local"}.WithDeployTarget(model.LocalTarget{})
+
+	expected := []struct {
+		name          string
+		targetTypes   []proto_webview.TargetType
+		hasLiveUpdate bool
+	}{
+		{"noLiveUpd", []proto_webview.TargetType{proto_webview.TargetType_TARGET_TYPE_IMAGE, proto_webview.TargetType_TARGET_TYPE_K8S}, false},
+		{"liveUpd", []proto_webview.TargetType{proto_webview.TargetType_TARGET_TYPE_IMAGE, proto_webview.TargetType_TARGET_TYPE_K8S}, true},
+		{"local", []proto_webview.TargetType{proto_webview.TargetType_TARGET_TYPE_LOCAL}, false},
+	}
+	state := newState([]model.Manifest{mNoLiveUpd, mLiveUpd, mLocal})
+	v := stateToProtoView(t, *state)
+
+	require.Equal(t, 4, len(v.Resources))
+	for i, r := range v.Resources {
+		if i == 0 {
+			continue // skip Tiltfile
+		}
+		expected := expected[i-1]
+		require.Equal(t, expected.name, r.Name, "name mismatch for resource at index %d", i)
+		observedTypes := []proto_webview.TargetType{}
+		var iTargHasLU bool
+		for _, spec := range r.Specs {
+			observedTypes = append(observedTypes, spec.Type)
+			if spec.Type == proto_webview.TargetType_TARGET_TYPE_IMAGE {
+				iTargHasLU = spec.HasLiveUpdate
+			}
+		}
+		require.ElementsMatch(t, expected.targetTypes, observedTypes, "for resource %q", r.Name)
+		require.Equal(t, expected.hasLiveUpdate, iTargHasLU, "for resource %q", r.Name)
+	}
+}
+
+func mustTimeToProto(t time.Time) *timestamp.Timestamp {
+	ts, err := timeToProto(t)
+	if err != nil {
+		panic(err)
+	}
+	return ts
+}
 func findResource(n model.ManifestName, view *proto_webview.View) (*proto_webview.Resource, bool) {
 	for _, res := range view.Resources {
 		if res.Name == n.String() {

internal/hud/webview/view.go

@@ -2,6 +2,7 @@ package webview
 
 // TODO(dmiller): delete these tests once StateToWebView is deleted
 import (
+	"fmt"
 	"time"
 
 	"github.com/windmilleng/tilt/internal/container"
@@ -37,6 +38,76 @@ func timeToProto(t time.Time) (*timestamp.Timestamp, error) {
 	return ts, nil
 }
 
+func buildTypesToProtoUpdateTypes(bts []model.BuildType) ([]proto_webview.UpdateType, error) {
+	result := make([]proto_webview.UpdateType, len(bts))
+	for i, bt := range bts {
+		protoType, err := buildTypeToProto(bt)
+		if err != nil {
+			return nil, err
+		}
+		result[i] = protoType
+	}
+	return result, nil
+}
+
+func buildTypeToProto(bt model.BuildType) (proto_webview.UpdateType, error) {
+	switch bt {
+	case model.BuildTypeImage:
+		return proto_webview.UpdateType_UPDATE_TYPE_IMAGE, nil
+	case model.BuildTypeLiveUpdate:
+		return proto_webview.UpdateType_UPDATE_TYPE_LIVE_UPDATE, nil
+	case model.BuildTypeDockerCompose:
+		return proto_webview.UpdateType_UPDATE_TYPE_DOCKER_COMPOSE, nil
+	case model.BuildTypeK8s:
+		return proto_webview.UpdateType_UPDATE_TYPE_K8S, nil
+	case model.BuildTypeLocal:
+		return proto_webview.UpdateType_UPDATE_TYPE_LOCAL, nil
+	default:
+		return proto_webview.UpdateType_UPDATE_TYPE_UNSPECIFIED, fmt.Errorf("unknown build type '%v'", bt)
+	}
+}
+
+func targetSpecToProto(spec model.TargetSpec) (proto_webview.TargetSpec, error) {
+	switch typ := spec.(type) {
+	case model.ImageTarget:
+		return proto_webview.TargetSpec{
+			Id:            typ.ID().String(),
+			Type:          proto_webview.TargetType_TARGET_TYPE_IMAGE,
+			HasLiveUpdate: !typ.LiveUpdateInfo().Empty(),
+		}, nil
+	case model.DockerComposeTarget:
+		return proto_webview.TargetSpec{
+			Id:   typ.ID().String(),
+			Type: proto_webview.TargetType_TARGET_TYPE_DOCKER_COMPOSE,
+		}, nil
+	case model.K8sTarget:
+		return proto_webview.TargetSpec{
+			Id:   typ.ID().String(),
+			Type: proto_webview.TargetType_TARGET_TYPE_K8S,
+		}, nil
+	case model.LocalTarget:
+		return proto_webview.TargetSpec{
+			Id:   typ.ID().String(),
+			Type: proto_webview.TargetType_TARGET_TYPE_LOCAL,
+		}, nil
+	default:
+		return proto_webview.TargetSpec{}, fmt.Errorf("unknown TargetSpec type %T for spec: '%v'", spec, spec)
+	}
+}
+
+func TargetSpecsToProto(specs []model.TargetSpec) ([]*proto_webview.TargetSpec, error) {
+	result := make([]*proto_webview.TargetSpec, len(specs))
+	for i, spec := range specs {
+		protoSpec, err := targetSpecToProto(spec)
+		if err != nil {
+			return nil, err
+		}
+		result[i] = &protoSpec
+	}
+
+	return result, nil
+}
+
 func ToProtoBuildRecord(br model.BuildRecord, logStore *logstore.LogStore) (*proto_webview.BuildRecord, error) {
 	e := ""
 	if br.Error != nil {
@@ -57,13 +128,18 @@ func ToProtoBuildRecord(br model.BuildRecord, logStore *logstore.LogStore) (*pro
 		warnings = logStore.Warnings(br.SpanID)
 	}
 
+	updateTypes, err := buildTypesToProtoUpdateTypes(br.BuildTypes)
+	if err != nil {
+		return nil, err
+	}
 	return &proto_webview.BuildRecord{
 		Edits: br.Edits,
 		Error: e,
 		// TODO(nick): Remove this, and compute it client-side.
 		Warnings:       warnings,
 		StartTime:      start,
 		FinishTime:     finish,
+		UpdateTypes:    updateTypes,
 		IsCrashRebuild: br.Reason.IsCrashOnly(),
 		SpanId:         string(br.SpanID),
 	}, nil