package top
import (
"fmt"
"io"
"strings"
"github.com/spf13/cobra"
kapi "k8s.io/kubernetes/pkg/api"
kclient "k8s.io/kubernetes/pkg/client/unversioned"
kcmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
"k8s.io/kubernetes/pkg/util/sets"
"github.com/openshift/origin/pkg/api/graph"
kubegraph "github.com/openshift/origin/pkg/api/kubegraph/nodes"
buildapi "github.com/openshift/origin/pkg/build/api"
"github.com/openshift/origin/pkg/client"
"github.com/openshift/origin/pkg/cmd/templates"
"github.com/openshift/origin/pkg/cmd/util/clientcmd"
deployapi "github.com/openshift/origin/pkg/deploy/api"
imageapi "github.com/openshift/origin/pkg/image/api"
imagegraph "github.com/openshift/origin/pkg/image/graph/nodes"
)
const (
TopImagesRecommendedName = "images"
maxImageIDLength = 20
)
var (
topImagesLong = templates.LongDesc(`
Show usage statistics for Images
This command analyzes all the Images managed by the platform and presents current
usage statistics.`)
topImagesExample = templates.Examples(`
# Show usage statistics for Images
%[1]s %[2]s`)
)
// NewCmdTopImages implements the OpenShift cli top images command.
func NewCmdTopImages(f *clientcmd.Factory, parentName, name string, out io.Writer) *cobra.Command {
opts := &TopImagesOptions{}
cmd := &cobra.Command{
Use: name,
Short: "Show usage statistics for Images",
Long: topImagesLong,
Example: fmt.Sprintf(topImagesExample, parentName, name),
Run: func(cmd *cobra.Command, args []string) {
kcmdutil.CheckErr(opts.Complete(f, cmd, args, out))
kcmdutil.CheckErr(opts.Validate(cmd))
kcmdutil.CheckErr(opts.Run())
},
}
return cmd
}
type TopImagesOptions struct {
// internal values
Images *imageapi.ImageList
Streams *imageapi.ImageStreamList
Pods *kapi.PodList
// helpers
out io.Writer
osClient client.Interface
kClient kclient.Interface
}
// Complete turns a partially defined TopImagesOptions into a solvent structure
// which can be validated and used for showing limits usage.
func (o *TopImagesOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, args []string, out io.Writer) error {
osClient, kClient, err := f.Clients()
if err != nil {
return err
}
namespace := cmd.Flag("namespace").Value.String()
if len(namespace) == 0 {
namespace = kapi.NamespaceAll
}
o.out = out
allImages, err := osClient.Images().List(kapi.ListOptions{})
if err != nil {
return err
}
o.Images = allImages
allStreams, err := osClient.ImageStreams(namespace).List(kapi.ListOptions{})
if err != nil {
return err
}
o.Streams = allStreams
allPods, err := kClient.Pods(namespace).List(kapi.ListOptions{})
if err != nil {
return err
}
o.Pods = allPods
return nil
}
// Validate ensures that a TopImagesOptions is valid and can be used to execute command.
func (o TopImagesOptions) Validate(cmd *cobra.Command) error {
return nil
}
// Run contains all the necessary functionality to show current image references.
func (o TopImagesOptions) Run() error {
infos := o.imagesTop()
Print(o.out, ImageColumns, infos)
return nil
}
var ImageColumns = []string{"NAME", "IMAGESTREAMTAG", "PARENTS", "USAGE", "METADATA", "STORAGE"}
// imageInfo contains statistic information about Image usage.
type imageInfo struct {
Image string
ImageStreamTags []string
Parents []string
Usage []string
Metadata bool
Storage int64
}
var _ Info = &imageInfo{}
func (i imageInfo) PrintLine(out io.Writer) {
printValue(out, i.Image)
printArray(out, i.ImageStreamTags)
shortParents := make([]string, len(i.Parents))
for i, p := range i.Parents {
if len(p) > maxImageIDLength {
shortParents[i] = p[:maxImageIDLength-3] + "..."
} else {
shortParents[i] = p
}
}
printArray(out, shortParents)
printArray(out, i.Usage)
printBool(out, i.Metadata)
printSize(out, i.Storage)
}
// imagesTop generates Image information from a graph and returns this as a list
// of imageInfo array.
func (o TopImagesOptions) imagesTop() []Info {
g := graph.New()
addImagesToGraph(g, o.Images)
addImageStreamsToGraph(g, o.Streams)
addPodsToGraph(g, o.Pods)
markParentsInGraph(g)
infos := []Info{}
imageNodes := getImageNodes(g.Nodes())
for _, in := range imageNodes {
image := in.Image
istags := getImageStreamTags(g, in)
parents := getImageParents(g, in)
usage := getImageUsage(g, in)
metadata := len(image.DockerImageManifest) != 0 && len(image.DockerImageLayers) != 0
storage := getStorage(image)
infos = append(infos, imageInfo{
Image: image.Name,
ImageStreamTags: istags,
Parents: parents,
Usage: usage,
Metadata: metadata,
Storage: storage,
})
}
return infos
}
func getStorage(image *imageapi.Image) int64 {
storage := int64(0)
blobSet := sets.NewString()
for _, layer := range image.DockerImageLayers {
if blobSet.Has(layer.Name) {
continue
}
blobSet.Insert(layer.Name)
storage += layer.LayerSize
}
if len(image.DockerImageConfig) > 0 && !blobSet.Has(image.DockerImageMetadata.ID) {
blobSet.Insert(image.DockerImageMetadata.ID)
storage += int64(len(image.DockerImageConfig))
}
return storage
}
func getImageStreamTags(g graph.Graph, node *imagegraph.ImageNode) []string {
istags := []string{}
for _, e := range g.InboundEdges(node, ImageStreamImageEdgeKind) {
streamNode, ok := e.From().(*imagegraph.ImageStreamNode)
if !ok {
continue
}
stream := streamNode.ImageStream
tags := getTags(stream, node.Image)
istags = append(istags, fmt.Sprintf("%s/%s (%s)", stream.Namespace, stream.Name, strings.Join(tags, ",")))
}
return istags
}
func getTags(stream *imageapi.ImageStream, image *imageapi.Image) []string {
tags := []string{}
for tag, history := range stream.Status.Tags {
if history.Items[0].Image == image.Name {
tags = append(tags, tag)
}
}
imageapi.PrioritizeTags(tags)
return tags
}
func getImageParents(g graph.Graph, node *imagegraph.ImageNode) []string {
parents := []string{}
for _, e := range g.InboundEdges(node, ParentImageEdgeKind) {
imageNode, ok := e.From().(*imagegraph.ImageNode)
if !ok {
continue
}
parents = append(parents, imageNode.Image.Name)
}
return parents
}
func getImageUsage(g graph.Graph, node *imagegraph.ImageNode) []string {
usage := []string{}
for _, e := range g.InboundEdges(node, PodImageEdgeKind) {
podNode, ok := e.From().(*kubegraph.PodNode)
if !ok {
continue
}
usage = append(usage, getController(podNode.Pod))
}
return usage
}
func getController(pod *kapi.Pod) string {
controller := "<unknown>"
if pod.Annotations == nil {
return controller
}
if bc, ok := pod.Annotations[buildapi.BuildAnnotation]; ok {
return fmt.Sprintf("Build: %s/%s", pod.Namespace, bc)
}
if dc, ok := pod.Annotations[deployapi.DeploymentAnnotation]; ok {
return fmt.Sprintf("Deployment: %s/%s", pod.Namespace, dc)
}
if dc, ok := pod.Annotations[deployapi.DeploymentPodAnnotation]; ok {
return fmt.Sprintf("Deployer: %s/%s", pod.Namespace, dc)
}
return controller
}