Hide manifests behind button toggle (#2841)

Signed-off-by: Sam Foo <[email protected]>

cmd/octant-sample-plugin/main.go

@@ -64,8 +64,8 @@ func main() {
  logger.Info("octant-sample-plugin is starting, with logger helper")
  service.SetupPluginLogger(service.Info)
  // OUTPUT: 2021-08-23T11:35:02.714-0500 INFO octant-sample-plugin plugin/logger.go:43 octant-sample-plugin is starting, with logger helper {"timestamp": "2021-08-23T11:35:02.714-0500"}
- log.Println("octant-sample-plugin is starting, with with prefix logger")
- // OUTPUT: 2021-08-23T11:35:02.714-0500 INFO octant-sample-plugin plugin/logger.go:43 [INFO] 2021/08/23 11:35:02 octant-sample-plugin is starting, with with prefix logger
+ log.Println("octant-sample-plugin is starting with prefix logger")
+ // OUTPUT: 2021-08-23T11:35:02.714-0500 INFO octant-sample-plugin plugin/logger.go:43 [INFO] 2021/08/23 11:35:02 octant-sample-plugin is starting with prefix logger
  p.Serve()
 
 }

internal/printer/manifest.go → internal/manifest/manifest.go

@@ -1,12 +1,12 @@
-package printer
+package manifest
 
 import (
- context "context"
+ "context"
  "fmt"
  "strings"
  "sync"
 
- "github.com/containers/image/v5/image"
+ imagev5 "github.com/containers/image/v5/image"
  "github.com/containers/image/v5/transports/alltransports"
  "github.com/containers/image/v5/types"
 
@@ -33,15 +33,32 @@ var (
 )
 
 func NewManifestConfiguration() *ManifestConfiguration {
- mc := &ManifestConfiguration{}
+ mc := &ManifestConfiguration{
+ imageCache: make(map[ImageEntry]ImageManifest),
+ }
  return mc
 }
 
-func (manifest *ManifestConfiguration) GetImageManifest(ctx context.Context, hostOS, imageName string) (string, string, error) {
+func (manifest *ManifestConfiguration) SetManifest(imageEntry ImageEntry, imageManifest ImageManifest) {
+ manifest.imageCache[imageEntry] = imageManifest
+}
+
+func (manifest *ManifestConfiguration) HasEntry(hostOS, imageName string) bool {
+ imageName = parseName(imageName)
+ _, ok := manifest.imageCache[ImageEntry{ImageName: imageName, HostOS: hostOS}]
+ return ok
+}
+
+func parseName(imageName string) string {
  parts := strings.SplitN(imageName, "://", 2) // if format not specified, assume docker
  if len(parts) != 2 {
  imageName = "docker://" + imageName
  }
+ return imageName
+}
+
+func (manifest *ManifestConfiguration) GetImageManifest(ctx context.Context, hostOS, imageName string) (string, string, error) {
+ imageName = parseName(imageName)
 
  imageEntry := ImageEntry{ImageName: imageName, HostOS: hostOS}
  if _, ok := manifest.imageCache[imageEntry]; ok {
@@ -62,28 +79,28 @@ func (manifest *ManifestConfiguration) GetImageManifest(ctx context.Context, hos
  if err != nil {
  return "", "", fmt.Errorf("error creating image source for image %s: %w", imageName, err)
  }
+ defer func() {
+ err = imageSrc.Close()
+ }()
 
  rawManifest, _, err := imageSrc.GetManifest(ctx, nil)
  if err != nil {
- return "", "", fmt.Errorf("error getting manifest for for image %s: %w", imageName, err)
+ return "", "", fmt.Errorf("error getting manifest for image %s: %w", imageName, err)
  }
 
- image, err := image.FromUnparsedImage(ctx, systemCtx, image.UnparsedInstance(imageSrc, nil))
+ image, err := imagev5.FromUnparsedImage(ctx, systemCtx, imagev5.UnparsedInstance(imageSrc, nil))
  if err != nil {
- return "", "", fmt.Errorf("error parsing manifest for for image %s: %w", imageName, err)
+ return "", "", fmt.Errorf("error parsing manifest for image %s: %w", imageName, err)
  }
 
  rawConfiguration, err := image.OCIConfig(ctx)
  if err != nil {
- return "", "", fmt.Errorf("error getting image config blob for for image %s: %w", imageName, err)
+ return "", "", fmt.Errorf("error getting image config blob for image %s: %w", imageName, err)
  }
 
  configOutput, err := json.MarshalIndent(rawConfiguration, "", " ")
 
- if manifest.imageCache == nil {
- manifest.imageCache = make(map[ImageEntry]ImageManifest)
- }
  manifest.imageCache[imageEntry] = ImageManifest{string(rawManifest), string(configOutput)}
 
- return string(rawManifest), string(configOutput), nil
+ return string(rawManifest), string(configOutput), err
 }

internal/printer/manifest_test.go → internal/manifest/manifest_test.go

@@ -1,8 +1,8 @@
-package printer
+package manifest
 
 import (
  "context"
- "fmt"
+ "os"
  "testing"
 
  "github.com/stretchr/testify/assert"
@@ -13,6 +13,9 @@ import (
 )
 
 func Test_GetImageManifest(t *testing.T) {
+ if os.Getenv("CI") != "" {
+ t.Skip("Skipping test in CI to avoid rate limits")
+ }
  tests := []struct {
  name string
  input string
@@ -48,7 +51,7 @@ func Test_GetImageManifest(t *testing.T) {
  manifestPath: "alpine_manifest.json",
  configPath: "alpine_config.json",
  hostOS: "windows",
- error: "error parsing manifest for for image docker://alpine:3.14.0: choosing image instance: no image found in manifest list for architecture amd64, variant \"\", OS windows",
+ error: "error parsing manifest for image docker://alpine:3.14.0: choosing image instance: no image found in manifest list for architecture amd64, variant \"\", OS windows",
  },
  }
  mc := NewManifestConfiguration()
@@ -61,7 +64,6 @@ func Test_GetImageManifest(t *testing.T) {
  expectedConfig := string(inputConfig)[:len(inputConfig)-1]
 
  manifest, config, err := mc.GetImageManifest(context.Background(), tt.hostOS, tt.input)
- fmt.Println("err", err)
  if len(tt.error) > 0 {
  assert.EqualError(t, err, tt.error)
  return

internal/modules/overview/overview.go

@@ -303,6 +303,7 @@ func (co *Overview) ActionPaths() map[string]action.DispatcherFunc {
  octant.NewCronJobResume(co.dashConfig.ObjectStore(), co.dashConfig.ClusterClient()),
  octant.NewObjectUpdaterDispatcher(co.dashConfig.ObjectStore()),
  octant.NewApplyYaml(co.logger, co.dashConfig.ObjectStore()),
+ octant.NewManifest(co.logger),
  }
 
  return dispatchers.ToActionPaths()

internal/octant/actions.go

@@ -22,6 +22,7 @@ const (
  ActionOverviewServiceEditor = "action.octant.dev/serviceEditor"
  ActionDeploymentConfiguration = "action.octant.dev/deploymentConfiguration"
  ActionUpdateObject = "action.octant.dev/update"
+ ActionGetManifest = "action.octant.dev/manifest"
 )
 
 func sendAlert(alerter action.Alerter, alertType action.AlertType, message string, expiration *time.Time) {

internal/octant/manifest.go

@@ -0,0 +1,42 @@
+package octant
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/vmware-tanzu/octant/internal/manifest"
+ "github.com/vmware-tanzu/octant/pkg/action"
+ "github.com/vmware-tanzu/octant/pkg/log"
+)
+
+type Manifest struct {
+ logger log.Logger
+}
+
+var _ action.Dispatcher = (*Manifest)(nil)
+
+func NewManifest(logger log.Logger) *Manifest {
+ return &Manifest{logger: logger}
+}
+
+func (m *Manifest) ActionName() string {
+ return ActionGetManifest
+}
+
+func (m *Manifest) Handle(ctx context.Context, _ action.Alerter, payload action.Payload) error {
+ m.logger.With("payload", payload).Debugf("received action payload")
+ image, err := payload.String("image")
+ if err != nil {
+ return err
+ }
+ hostOS, err := payload.String("host")
+ if err != nil {
+ return err
+ }
+
+ _, _, err = manifest.ManifestManager.GetImageManifest(ctx, hostOS, image)
+ if err != nil {
+ return fmt.Errorf("getting manifest for image %s: %w", image, err)
+ }
+ return nil
+}

internal/printer/container.go

@@ -8,16 +8,16 @@ package printer
 import (
  "context"
  "fmt"
+ "path"
+ "sort"
+ "strings"
 
  "github.com/vmware-tanzu/octant/internal/api"
- "github.com/vmware-tanzu/octant/internal/util/json"
-
  "github.com/vmware-tanzu/octant/internal/log"
+ "github.com/vmware-tanzu/octant/internal/manifest"
+ "github.com/vmware-tanzu/octant/internal/util/json"
  "github.com/vmware-tanzu/octant/internal/util/kubernetes"
-
- "path"
- "sort"
- "strings"
+ "github.com/vmware-tanzu/octant/pkg/action"
 
  "github.com/vmware-tanzu/octant/internal/octant"
 
@@ -128,12 +128,16 @@ func (cc *ContainerConfiguration) Create() (*component.Summary, error) {
  sections.AddText("Image ID", containerStatus.ImageID)
  }
 
- manifest, configuration, err := ManifestManager.GetImageManifest(cc.context, hostOS, c.Image)
- if err == nil {
- sections.Add("Image Manifest", component.NewJSONEditor(manifest, true))
- sections.Add("Image Configuration", component.NewJSONEditor(configuration, true))
+ if !manifest.ManifestManager.HasEntry(hostOS, c.Image) {
+ sections.Add("Image Manifest", component.NewButton("Show Manifest", action.CreatePayload(octant.ActionGetManifest, map[string]interface{}{"host": hostOS, "image": c.Image})))
  } else {
- sections.Add("Image Manifest", component.NewText(fmt.Sprintf("Unable to load image manifest %s", err)))
+ manifest, configuration, err := manifest.ManifestManager.GetImageManifest(cc.context, hostOS, c.Image)
+ if err == nil {
+ sections.Add("Image Manifest", component.NewJSONEditor(manifest, true))
+ sections.Add("Image Configuration", component.NewJSONEditor(configuration, true))
+ } else {
+ sections.Add("Image Manifest", component.NewText(fmt.Sprintf("Unable to load image manifest %s", err)))
+ }
  }
 
  hostPorts := describeContainerHostPorts(c.Ports)