@@ -7,6 +7,7 @@ import (

 	"io"

 	"io/ioutil"

 	"net/http"

+	"net/url"

 	"os"

 	"strings"

 	"text/tabwriter"

@@ -16,7 +17,7 @@ import (

 	kapi "k8s.io/kubernetes/pkg/api"

 	"k8s.io/kubernetes/pkg/client/restclient"

 	kclient "k8s.io/kubernetes/pkg/client/unversioned"

-	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"

+	kcmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"

 	knet "k8s.io/kubernetes/pkg/util/net"

 	"github.com/openshift/origin/pkg/client"

@@ -47,21 +48,20 @@ images.`

   %[1]s %[2]s --keep-tag-revisions=3 --keep-younger-than=60m --confirm`

 )

-// PruneImagesOptions holds all the required options for prune images

+// PruneImagesOptions holds all the required options for pruning images.

 type PruneImagesOptions struct {

-	Pruner prune.ImageRegistryPruner

-	Client client.Interface

-	Out    io.Writer

-

-	Confirm          bool

-	KeepYoungerThan  time.Duration

-	KeepTagRevisions int

-

+	Confirm             bool

+	KeepYoungerThan     time.Duration

+	KeepTagRevisions    int

 	CABundle            string

 	RegistryUrlOverride string

+

+	Pruner prune.Pruner

+	Client client.Interface

+	Out    io.Writer

 }

-// NewCmdPruneImages implements the OpenShift cli prune images command

+// NewCmdPruneImages implements the OpenShift cli prune images command.

 func NewCmdPruneImages(f *clientcmd.Factory, parentName, name string, out io.Writer) *cobra.Command {

 	opts := &PruneImagesOptions{

 		Confirm:          false,

@@ -77,17 +77,9 @@ func NewCmdPruneImages(f *clientcmd.Factory, parentName, name string, out io.Wri

 		Example: fmt.Sprintf(imagesExample, parentName, name),

 		Run: func(cmd *cobra.Command, args []string) {

-			if err := opts.Complete(f, args, out); err != nil {

-				cmdutil.CheckErr(err)

-			}

-

-			if err := opts.Validate(); err != nil {

-				cmdutil.CheckErr(cmdutil.UsageError(cmd, err.Error()))

-			}

-

-			if err := opts.RunPruneImages(); err != nil {

-				cmdutil.CheckErr(err)

-			}

+			kcmdutil.CheckErr(opts.Complete(f, cmd, args, out))

+			kcmdutil.CheckErr(opts.Validate())

+			kcmdutil.CheckErr(opts.Run())

 		},

 	}

@@ -100,10 +92,11 @@ func NewCmdPruneImages(f *clientcmd.Factory, parentName, name string, out io.Wri

 	return cmd

 }

-// Complete the options for prune images

-func (o *PruneImagesOptions) Complete(f *clientcmd.Factory, args []string, out io.Writer) error {

+// Complete turns a partially defined PruneImagesOptions into a solvent structure

+// which can be validated and used for pruning images.

+func (o *PruneImagesOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, args []string, out io.Writer) error {

 	if len(args) > 0 {

-		return errors.New("no arguments are allowed to this command")

+		return kcmdutil.UsageError(cmd, "no arguments are allowed to this command")

 	}

 	o.Out = out

@@ -153,7 +146,7 @@ func (o *PruneImagesOptions) Complete(f *clientcmd.Factory, args []string, out i

 		return err

 	}

-	options := prune.ImageRegistryPrunerOptions{

+	options := prune.PrunerOptions{

 		KeepYoungerThan:  o.KeepYoungerThan,

 		KeepTagRevisions: o.KeepTagRevisions,

 		Images:           allImages,

@@ -168,61 +161,60 @@ func (o *PruneImagesOptions) Complete(f *clientcmd.Factory, args []string, out i

 		RegistryURL:      o.RegistryUrlOverride,

 	}

-	o.Pruner = prune.NewImageRegistryPruner(options)

+	o.Pruner = prune.NewPruner(options)

 	return nil

 }

-// Validate the options for prune images

-func (o *PruneImagesOptions) Validate() error {

-	if o.Pruner == nil && o.Confirm {

-		return errors.New("an image pruner needs to be specified")

+// Validate ensures that a PruneImagesOptions is valid and can be used to execute pruning.

+func (o PruneImagesOptions) Validate() error {

+	if o.KeepYoungerThan < 0 {

+		return fmt.Errorf("--keep-younger-than must be greater than or equal to 0")

 	}

-	if o.Client == nil {

-		return errors.New("a client needs to be specified")

+	if o.KeepTagRevisions < 0 {

+		return fmt.Errorf("--keep-tag-revisions must be greater than or equal to 0")

 	}

-	if o.Out == nil {

-		return errors.New("a writer needs to be specified")

+	if _, err := url.Parse(o.RegistryUrlOverride); err != nil {

+		return fmt.Errorf("invalid --registry-url flag: %v", err)

 	}

 	return nil

 }

-// RunPruneImages runs the prune images cli command

-func (o *PruneImagesOptions) RunPruneImages() error {

-	// this tabwriter is used by the describing*Pruners below for their output

+// Run contains all the necessary functionality for the OpenShift cli prune images command.

+func (o PruneImagesOptions) Run() error {

 	w := tabwriter.NewWriter(o.Out, 10, 4, 3, ' ', 0)

 	defer w.Flush()

-	imagePruner := &describingImagePruner{w: w}

-	imageStreamPruner := &describingImageStreamPruner{w: w}

-	layerPruner := &describingLayerPruner{w: w}

-	blobPruner := &describingBlobPruner{w: w}

-	manifestPruner := &describingManifestPruner{w: w}

+	imageDeleter := &describingImageDeleter{w: w}

+	imageStreamDeleter := &describingImageStreamDeleter{w: w}

+	layerDeleter := &describingLayerDeleter{w: w}

+	blobDeleter := &describingBlobDeleter{w: w}

+	manifestDeleter := &describingManifestDeleter{w: w}

 	if o.Confirm {

-		imagePruner.delegate = prune.NewDeletingImagePruner(o.Client.Images())

-		imageStreamPruner.delegate = prune.NewDeletingImageStreamPruner(o.Client)

-		layerPruner.delegate = prune.NewDeletingLayerPruner()

-		blobPruner.delegate = prune.NewDeletingBlobPruner()

-		manifestPruner.delegate = prune.NewDeletingManifestPruner()

+		imageDeleter.delegate = prune.NewImageDeleter(o.Client.Images())

+		imageStreamDeleter.delegate = prune.NewImageStreamDeleter(o.Client)

+		layerDeleter.delegate = prune.NewLayerDeleter()

+		blobDeleter.delegate = prune.NewBlobDeleter()

+		manifestDeleter.delegate = prune.NewManifestDeleter()

 	} else {

 		fmt.Fprintln(os.Stderr, "Dry run enabled - no modifications will be made. Add --confirm to remove images")

 	}

-	return o.Pruner.Prune(imagePruner, imageStreamPruner, layerPruner, blobPruner, manifestPruner)

+	return o.Pruner.Prune(imageDeleter, imageStreamDeleter, layerDeleter, blobDeleter, manifestDeleter)

 }

-// describingImageStreamPruner prints information about each image stream update.

-// If a delegate exists, its PruneImageStream function is invoked prior to returning.

-type describingImageStreamPruner struct {

+// describingImageStreamDeleter prints information about each image stream update.

+// If a delegate exists, its DeleteImageStream function is invoked prior to returning.

+type describingImageStreamDeleter struct {

 	w             io.Writer

-	delegate      prune.ImageStreamPruner

+	delegate      prune.ImageStreamDeleter

 	headerPrinted bool

 }

-var _ prune.ImageStreamPruner = &describingImageStreamPruner{}

+var _ prune.ImageStreamDeleter = &describingImageStreamDeleter{}

-func (p *describingImageStreamPruner) PruneImageStream(stream *imageapi.ImageStream, image *imageapi.Image, updatedTags []string) (*imageapi.ImageStream, error) {

+func (p *describingImageStreamDeleter) DeleteImageStream(stream *imageapi.ImageStream, image *imageapi.Image, updatedTags []string) (*imageapi.ImageStream, error) {

 	if !p.headerPrinted {

 		p.headerPrinted = true

 		fmt.Fprintln(p.w, "Deleting references from image streams to images ...")

@@ -235,7 +227,7 @@ func (p *describingImageStreamPruner) PruneImageStream(stream *imageapi.ImageStr

 		return stream, nil

 	}

-	updatedStream, err := p.delegate.PruneImageStream(stream, image, updatedTags)

+	updatedStream, err := p.delegate.DeleteImageStream(stream, image, updatedTags)

 	if err != nil {

 		fmt.Fprintf(os.Stderr, "error updating image stream %s/%s to remove references to image %s: %v\n", stream.Namespace, stream.Name, image.Name, err)

 	}

@@ -243,17 +235,17 @@ func (p *describingImageStreamPruner) PruneImageStream(stream *imageapi.ImageStr

 	return updatedStream, err

 }

-// describingImagePruner prints information about each image being deleted.

-// If a delegate exists, its PruneImage function is invoked prior to returning.

-type describingImagePruner struct {

+// describingImageDeleter prints information about each image being deleted.

+// If a delegate exists, its DeleteImage function is invoked prior to returning.

+type describingImageDeleter struct {

 	w             io.Writer

-	delegate      prune.ImagePruner

+	delegate      prune.ImageDeleter

 	headerPrinted bool

 }

-var _ prune.ImagePruner = &describingImagePruner{}

+var _ prune.ImageDeleter = &describingImageDeleter{}

-func (p *describingImagePruner) PruneImage(image *imageapi.Image) error {

+func (p *describingImageDeleter) DeleteImage(image *imageapi.Image) error {

 	if !p.headerPrinted {

 		p.headerPrinted = true

 		fmt.Fprintln(p.w, "\nDeleting images from server ...")

@@ -266,7 +258,7 @@ func (p *describingImagePruner) PruneImage(image *imageapi.Image) error {

 		return nil

 	}

-	err := p.delegate.PruneImage(image)

+	err := p.delegate.DeleteImage(image)

 	if err != nil {

 		fmt.Fprintf(os.Stderr, "error deleting image %s from server: %v\n", image.Name, err)

 	}

@@ -274,18 +266,18 @@ func (p *describingImagePruner) PruneImage(image *imageapi.Image) error {

 	return err

 }

-// describingLayerPruner prints information about each repo layer link being

-// deleted. If a delegate exists, its PruneLayer function is invoked prior to

+// describingLayerDeleter prints information about each repo layer link being

+// deleted. If a delegate exists, its DeleteLayer function is invoked prior to

 // returning.

-type describingLayerPruner struct {

+type describingLayerDeleter struct {

 	w             io.Writer

-	delegate      prune.LayerPruner

+	delegate      prune.LayerDeleter

 	headerPrinted bool

 }

-var _ prune.LayerPruner = &describingLayerPruner{}

+var _ prune.LayerDeleter = &describingLayerDeleter{}

-func (p *describingLayerPruner) PruneLayer(registryClient *http.Client, registryURL, repo, layer string) error {

+func (p *describingLayerDeleter) DeleteLayer(registryClient *http.Client, registryURL, repo, layer string) error {

 	if !p.headerPrinted {

 		p.headerPrinted = true

 		fmt.Fprintln(p.w, "\nDeleting registry repository layer links ...")

@@ -298,7 +290,7 @@ func (p *describingLayerPruner) PruneLayer(registryClient *http.Client, registry

 		return nil

 	}

-	err := p.delegate.PruneLayer(registryClient, registryURL, repo, layer)

+	err := p.delegate.DeleteLayer(registryClient, registryURL, repo, layer)

 	if err != nil {

 		fmt.Fprintf(os.Stderr, "error deleting repository %s layer link %s from the registry: %v\n", repo, layer, err)

 	}

@@ -306,17 +298,17 @@ func (p *describingLayerPruner) PruneLayer(registryClient *http.Client, registry

 	return err

 }

-// describingBlobPruner prints information about each blob being deleted. If a

-// delegate exists, its PruneBlob function is invoked prior to returning.

-type describingBlobPruner struct {

+// describingBlobDeleter prints information about each blob being deleted. If a

+// delegate exists, its DeleteBlob function is invoked prior to returning.

+type describingBlobDeleter struct {

 	w             io.Writer

-	delegate      prune.BlobPruner

+	delegate      prune.BlobDeleter

 	headerPrinted bool

 }

-var _ prune.BlobPruner = &describingBlobPruner{}

+var _ prune.BlobDeleter = &describingBlobDeleter{}

-func (p *describingBlobPruner) PruneBlob(registryClient *http.Client, registryURL, layer string) error {

+func (p *describingBlobDeleter) DeleteBlob(registryClient *http.Client, registryURL, layer string) error {

 	if !p.headerPrinted {

 		p.headerPrinted = true

 		fmt.Fprintln(p.w, "\nDeleting registry layer blobs ...")

@@ -329,7 +321,7 @@ func (p *describingBlobPruner) PruneBlob(registryClient *http.Client, registryUR

 		return nil

 	}

-	err := p.delegate.PruneBlob(registryClient, registryURL, layer)

+	err := p.delegate.DeleteBlob(registryClient, registryURL, layer)

 	if err != nil {

 		fmt.Fprintf(os.Stderr, "error deleting blob %s from the registry: %v\n", layer, err)

 	}

@@ -337,18 +329,18 @@ func (p *describingBlobPruner) PruneBlob(registryClient *http.Client, registryUR

 	return err

 }

-// describingManifestPruner prints information about each repo manifest being

-// deleted. If a delegate exists, its PruneManifest function is invoked prior

+// describingManifestDeleter prints information about each repo manifest being

+// deleted. If a delegate exists, its DeleteManifest function is invoked prior

 // to returning.

-type describingManifestPruner struct {

+type describingManifestDeleter struct {

 	w             io.Writer

-	delegate      prune.ManifestPruner

+	delegate      prune.ManifestDeleter

 	headerPrinted bool

 }

-var _ prune.ManifestPruner = &describingManifestPruner{}

+var _ prune.ManifestDeleter = &describingManifestDeleter{}

-func (p *describingManifestPruner) PruneManifest(registryClient *http.Client, registryURL, repo, manifest string) error {

+func (p *describingManifestDeleter) DeleteManifest(registryClient *http.Client, registryURL, repo, manifest string) error {

 	if !p.headerPrinted {

 		p.headerPrinted = true

 		fmt.Fprintln(p.w, "\nDeleting registry repository manifest data ...")

@@ -361,7 +353,7 @@ func (p *describingManifestPruner) PruneManifest(registryClient *http.Client, re

 		return nil

 	}

-	err := p.delegate.PruneManifest(registryClient, registryURL, repo, manifest)

+	err := p.delegate.DeleteManifest(registryClient, registryURL, repo, manifest)

 	if err != nil {

 		fmt.Fprintf(os.Stderr, "error deleting data for repository %s image manifest %s from the registry: %v\n", repo, manifest, err)

 	}

@@ -391,7 +383,7 @@ func getClients(f *clientcmd.Factory, caBundle string) (*client.Client, *kclient

 		}

 		token = clientConfig.BearerToken

 	default:

-		err = errors.New("You must use a client config with a token")

+		err = errors.New("you must use a client config with a token")

 		return nil, nil, nil, err

 	}

deleted file mode 100644

@@ -1,1010 +0,0 @@

-package prune

-

-import (

-	"encoding/json"

-	"fmt"

-	"net/http"

-	"time"

-

-	"github.com/docker/distribution/registry/api/errcode"

-	"github.com/golang/glog"

-	gonum "github.com/gonum/graph"

-

-	kapi "k8s.io/kubernetes/pkg/api"

-	"k8s.io/kubernetes/pkg/api/unversioned"

-	kerrors "k8s.io/kubernetes/pkg/util/errors"

-	utilruntime "k8s.io/kubernetes/pkg/util/runtime"

-	"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"

-	buildgraph "github.com/openshift/origin/pkg/build/graph/nodes"

-	buildutil "github.com/openshift/origin/pkg/build/util"

-	"github.com/openshift/origin/pkg/client"

-	deployapi "github.com/openshift/origin/pkg/deploy/api"

-	deploygraph "github.com/openshift/origin/pkg/deploy/graph/nodes"

-	imageapi "github.com/openshift/origin/pkg/image/api"

-	imagegraph "github.com/openshift/origin/pkg/image/graph/nodes"

-)

-

-// TODO these edges should probably have an `Add***Edges` method in images/graph and be moved there

-const (

-	// ReferencedImageEdgeKind defines a "strong" edge where the tail is an

-	// ImageNode, with strong indicating that the ImageNode tail is not a

-	// candidate for pruning.

-	ReferencedImageEdgeKind = "ReferencedImage"

-	// WeakReferencedImageEdgeKind defines a "weak" edge where the tail is

-	// an ImageNode, with weak indicating that this particular edge does

-	// not keep an ImageNode from being a candidate for pruning.

-	WeakReferencedImageEdgeKind = "WeakReferencedImage"

-

-	// ReferencedImageLayerEdgeKind defines an edge from an ImageStreamNode or an

-	// ImageNode to an ImageLayerNode.

-	ReferencedImageLayerEdgeKind = "ReferencedImageLayer"

-)

-

-// pruneAlgorithm contains the various settings to use when evaluating images

-// and layers for pruning.

-type pruneAlgorithm struct {

-	keepYoungerThan  time.Duration

-	keepTagRevisions int

-}

-

-// ImagePruner knows how to delete images from OpenShift.

-type ImagePruner interface {

-	// PruneImage deletes the image from OpenShift's storage.

-	PruneImage(image *imageapi.Image) error

-}

-

-// ImageStreamPruner knows how to remove an image reference from an image

-// stream.

-type ImageStreamPruner interface {

-	// PruneImageStream deletes all references to the image from the image

-	// stream's status.tags. The updated image stream is returned.

-	PruneImageStream(stream *imageapi.ImageStream, image *imageapi.Image, updatedTags []string) (*imageapi.ImageStream, error)

-}

-

-// BlobPruner knows how to delete a blob from the Docker registry.

-type BlobPruner interface {

-	// PruneBlob uses registryClient to ask the registry at registryURL to delete

-	// the blob.

-	PruneBlob(registryClient *http.Client, registryURL, blob string) error

-}

-

-// LayerPruner knows how to delete a repository layer link from the Docker

-// registry.

-type LayerPruner interface {

-	// PruneLayer uses registryClient to ask the registry at registryURL to

-	// delete the repository layer link.

-	PruneLayer(registryClient *http.Client, registryURL, repo, layer string) error

-}

-

-// ManifestPruner knows how to delete image manifest data for a repository from

-// the Docker registry.

-type ManifestPruner interface {

-	// PruneManifest uses registryClient to ask the registry at registryURL to

-	// delete the repository's image manifest data.

-	PruneManifest(registryClient *http.Client, registryURL, repo, manifest string) error

-}

-

-// ImageRegistryPrunerOptions contains the fields used to initialize a new

-// ImageRegistryPruner.

-type ImageRegistryPrunerOptions struct {

-	// KeepYoungerThan indicates the minimum age an Image must be to be a

-	// candidate for pruning.

-	KeepYoungerThan time.Duration

-	// KeepTagRevisions is the minimum number of tag revisions to preserve;

-	// revisions older than this value are candidates for pruning.

-	KeepTagRevisions int

-	// Images is the entire list of images in OpenShift. An image must be in this

-	// list to be a candidate for pruning.

-	Images *imageapi.ImageList

-	// Streams is the entire list of image streams across all namespaces in the

-	// cluster.

-	Streams *imageapi.ImageStreamList

-	// Pods is the entire list of pods across all namespaces in the cluster.

-	Pods *kapi.PodList

-	// RCs is the entire list of replication controllers across all namespaces in

-	// the cluster.

-	RCs *kapi.ReplicationControllerList

-	// BCs is the entire list of build configs across all namespaces in the

-	// cluster.

-	BCs *buildapi.BuildConfigList

-	// Builds is the entire list of builds across all namespaces in the cluster.

-	Builds *buildapi.BuildList

-	// DCs is the entire list of deployment configs across all namespaces in the

-	// cluster.

-	DCs *deployapi.DeploymentConfigList

-	// DryRun indicates that no changes will be made to the cluster and nothing

-	// will be removed.

-	DryRun bool

-	// RegistryClient is the http.Client to use when contacting the registry.

-	RegistryClient *http.Client

-	// RegistryURL is the URL for the registry.

-	RegistryURL string

-}

-

-// ImageRegistryPruner knows how to prune images and layers.

-type ImageRegistryPruner interface {

-	// Prune uses imagePruner, streamPruner, layerPruner, blobPruner, and

-	// manifestPruner to remove images that have been identified as candidates

-	// for pruning based on the ImageRegistryPruner's internal pruning algorithm.

-	// Please see NewImageRegistryPruner for details on the algorithm.

-	Prune(imagePruner ImagePruner, streamPruner ImageStreamPruner, layerPruner LayerPruner, blobPruner BlobPruner, manifestPruner ManifestPruner) error

-}

-

-// imageRegistryPruner implements ImageRegistryPruner.

-type imageRegistryPruner struct {

-	g              graph.Graph

-	algorithm      pruneAlgorithm

-	registryPinger registryPinger

-	registryClient *http.Client

-	registryURL    string

-}

-

-var _ ImageRegistryPruner = &imageRegistryPruner{}

-

-// registryPinger performs a health check against a registry.

-type registryPinger interface {

-	// ping performs a health check against registry.

-	ping(registry string) error

-}

-

-// defaultRegistryPinger implements registryPinger.

-type defaultRegistryPinger struct {

-	client *http.Client

-}

-

-func (drp *defaultRegistryPinger) ping(registry string) error {

-	healthCheck := func(proto, registry string) error {

-		// TODO: `/healthz` route is deprecated by `/`; remove it in future versions

-		healthResponse, err := drp.client.Get(fmt.Sprintf("%s://%s/healthz", proto, registry))

-		if err != nil {

-			return err

-		}

-		defer healthResponse.Body.Close()

-

-		if healthResponse.StatusCode != http.StatusOK {

-			return fmt.Errorf("unexpected status code %d", healthResponse.StatusCode)

-		}

-

-		return nil

-	}

-

-	var err error

-	for _, proto := range []string{"https", "http"} {

-		glog.V(4).Infof("Trying %s for %s", proto, registry)

-		err = healthCheck(proto, registry)

-		if err == nil {

-			break

-		}

-		glog.V(4).Infof("Error with %s for %s: %v", proto, registry, err)

-	}

-

-	return err

-}

-

-// dryRunRegistryPinger implements registryPinger.

-type dryRunRegistryPinger struct {

-}

-

-func (*dryRunRegistryPinger) ping(registry string) error {

-	return nil

-}

-

-/*

-NewImageRegistryPruner creates a new ImageRegistryPruner.

-

-Images younger than keepYoungerThan and images referenced by image streams

-and/or pods younger than keepYoungerThan are preserved. All other images are

-candidates for pruning. For example, if keepYoungerThan is 60m, and an

-ImageStream is only 59 minutes old, none of the images it references are

-eligible for pruning.

-

-keepTagRevisions is the number of revisions per tag in an image stream's

-status.tags that are preserved and ineligible for pruning. Any revision older

-than keepTagRevisions is eligible for pruning.

-

-images, streams, pods, rcs, bcs, builds, and dcs are the resources used to run

-the pruning algorithm. These should be the full list for each type from the

-cluster; otherwise, the pruning algorithm might result in incorrect

-calculations and premature pruning.

-

-The ImagePruner performs the following logic: remove any image containing the

-annotation openshift.io/image.managed=true that was created at least *n*

-minutes ago and is *not* currently referenced by:

-

-- any pod created less than *n* minutes ago

-- any image stream created less than *n* minutes ago

-- any running pods

-- any pending pods

-- any replication controllers

-- any deployment configs

-- any build configs

-- any builds

-- the n most recent tag revisions in an image stream's status.tags

-

-When removing an image, remove all references to the image from all

-ImageStreams having a reference to the image in `status.tags`.

-

-Also automatically remove any image layer that is no longer referenced by any

-images.

-*/

-func NewImageRegistryPruner(options ImageRegistryPrunerOptions) ImageRegistryPruner {

-	g := graph.New()

-

-	glog.V(1).Infof("Creating image pruner with keepYoungerThan=%v, keepTagRevisions=%d", options.KeepYoungerThan, options.KeepTagRevisions)

-

-	algorithm := pruneAlgorithm{

-		keepYoungerThan:  options.KeepYoungerThan,

-		keepTagRevisions: options.KeepTagRevisions,

-	}

-

-	addImagesToGraph(g, options.Images, algorithm)

-	addImageStreamsToGraph(g, options.Streams, algorithm)

-	addPodsToGraph(g, options.Pods, algorithm)

-	addReplicationControllersToGraph(g, options.RCs)

-	addBuildConfigsToGraph(g, options.BCs)

-	addBuildsToGraph(g, options.Builds)

-	addDeploymentConfigsToGraph(g, options.DCs)

-

-	var rp registryPinger

-	if options.DryRun {

-		rp = &dryRunRegistryPinger{}

-	} else {

-		rp = &defaultRegistryPinger{options.RegistryClient}

-	}

-

-	return &imageRegistryPruner{

-		g:              g,

-		algorithm:      algorithm,

-		registryPinger: rp,

-		registryClient: options.RegistryClient,

-		registryURL:    options.RegistryURL,

-	}

-}

-

-// addImagesToGraph adds all images to the graph that belong to one of the

-// registries in the algorithm and are at least as old as the minimum age

-// threshold as specified by the algorithm. It also adds all the images' layers

-// to the graph.

-func addImagesToGraph(g graph.Graph, images *imageapi.ImageList, algorithm pruneAlgorithm) {

-	for i := range images.Items {

-		image := &images.Items[i]

-

-		glog.V(4).Infof("Examining image %q", image.Name)

-

-		if image.Annotations == nil {

-			glog.V(4).Infof("Image %q with DockerImageReference %q belongs to an external registry - skipping", image.Name, image.DockerImageReference)

-			continue

-		}

-		if value, ok := image.Annotations[imageapi.ManagedByOpenShiftAnnotation]; !ok || value != "true" {

-			glog.V(4).Infof("Image %q with DockerImageReference %q belongs to an external registry - skipping", image.Name, image.DockerImageReference)

-			continue

-		}

-

-		age := unversioned.Now().Sub(image.CreationTimestamp.Time)

-		if age < algorithm.keepYoungerThan {

-			glog.V(4).Infof("Image %q is younger than minimum pruning age, skipping (age=%v)", image.Name, age)

-			continue

-		}

-

-		glog.V(4).Infof("Adding image %q to graph", image.Name)

-		imageNode := imagegraph.EnsureImageNode(g, image)

-

-		manifest := imageapi.DockerImageManifest{}

-		if err := json.Unmarshal([]byte(image.DockerImageManifest), &manifest); err != nil {

-			utilruntime.HandleError(fmt.Errorf("unable to extract manifest from image: %v. This image's layers won't be pruned if the image is pruned now.", err))

-			continue

-		}

-

-		for _, layer := range manifest.FSLayers {

-			glog.V(4).Infof("Adding image layer %q to graph", layer.DockerBlobSum)

-			layerNode := imagegraph.EnsureImageLayerNode(g, layer.DockerBlobSum)

-			g.AddEdge(imageNode, layerNode, ReferencedImageLayerEdgeKind)

-		}

-	}

-}

-

-// addImageStreamsToGraph adds all the streams to the graph. The most recent n

-// image revisions for a tag will be preserved, where n is specified by the

-// algorithm's keepTagRevisions. Image revisions older than n are candidates

-// for pruning.  if the image stream's age is at least as old as the minimum

-// threshold in algorithm.  Otherwise, if the image stream is younger than the

-// threshold, all image revisions for that stream are ineligible for pruning.

-//

-// addImageStreamsToGraph also adds references from each stream to all the

-// layers it references (via each image a stream references).

-func addImageStreamsToGraph(g graph.Graph, streams *imageapi.ImageStreamList, algorithm pruneAlgorithm) {

-	for i := range streams.Items {

-		stream := &streams.Items[i]

-

-		glog.V(4).Infof("Examining ImageStream %s/%s", stream.Namespace, stream.Name)

-

-		// use a weak reference for old image revisions by default

-		oldImageRevisionReferenceKind := WeakReferencedImageEdgeKind

-

-		age := unversioned.Now().Sub(stream.CreationTimestamp.Time)

-		if age < algorithm.keepYoungerThan {

-			// stream's age is below threshold - use a strong reference for old image revisions instead

-			glog.V(4).Infof("Stream %s/%s is below age threshold - none of its images are eligible for pruning", stream.Namespace, stream.Name)

-			oldImageRevisionReferenceKind = ReferencedImageEdgeKind

-		}

-

-		glog.V(4).Infof("Adding ImageStream %s/%s to graph", stream.Namespace, stream.Name)

-		isNode := imagegraph.EnsureImageStreamNode(g, stream)

-		imageStreamNode := isNode.(*imagegraph.ImageStreamNode)

-

-		for tag, history := range stream.Status.Tags {

-			for i := range history.Items {

-				n := imagegraph.FindImage(g, history.Items[i].Image)

-				if n == nil {

-					glog.V(2).Infof("Unable to find image %q in graph (from tag=%q, revision=%d, dockerImageReference=%s)", history.Items[i].Image, tag, i, history.Items[i].DockerImageReference)

-					continue

-				}

-				imageNode := n.(*imagegraph.ImageNode)

-

-				var kind string

-				switch {

-				case i < algorithm.keepTagRevisions:

-					kind = ReferencedImageEdgeKind

-				default:

-					kind = oldImageRevisionReferenceKind

-				}

-

-				glog.V(4).Infof("Checking for existing strong reference from stream %s/%s to image %s", stream.Namespace, stream.Name, imageNode.Image.Name)

-				if edge := g.Edge(imageStreamNode, imageNode); edge != nil && g.EdgeKinds(edge).Has(ReferencedImageEdgeKind) {

-					glog.V(4).Infof("Strong reference found")

-					continue

-				}

-

-				glog.V(4).Infof("Adding edge (kind=%s) from %q to %q", kind, imageStreamNode.UniqueName(), imageNode.UniqueName())

-				g.AddEdge(imageStreamNode, imageNode, kind)

-

-				glog.V(4).Infof("Adding stream->layer references")

-				// add stream -> layer references so we can prune them later

-				for _, s := range g.From(imageNode) {

-					if g.Kind(s) != imagegraph.ImageLayerNodeKind {

-						continue

-					}

-					glog.V(4).Infof("Adding reference from stream %q to layer %q", stream.Name, s.(*imagegraph.ImageLayerNode).Layer)

-					g.AddEdge(imageStreamNode, s, ReferencedImageLayerEdgeKind)

-				}

-			}

-		}

-	}

-}

-

-// addPodsToGraph adds pods to the graph.

-//

-// A pod is only *excluded* from being added to the graph if its phase is not

-// pending or running and it is at least as old as the minimum age threshold

-// defined by algorithm.

-//

-// Edges are added to the graph from each pod to the images specified by that

-// pod's list of containers, as long as the image is managed by OpenShift.

-func addPodsToGraph(g graph.Graph, pods *kapi.PodList, algorithm pruneAlgorithm) {

-	for i := range pods.Items {

-		pod := &pods.Items[i]

-

-		glog.V(4).Infof("Examining pod %s/%s", pod.Namespace, pod.Name)

-

-		if pod.Status.Phase != kapi.PodRunning && pod.Status.Phase != kapi.PodPending {

-			age := unversioned.Now().Sub(pod.CreationTimestamp.Time)

-			if age >= algorithm.keepYoungerThan {

-				glog.V(4).Infof("Pod %s/%s is not running or pending and age is at least minimum pruning age - skipping", pod.Namespace, pod.Name)

-				// not pending or running, age is at least minimum pruning age, skip

-				continue

-			}

-		}

-

-		glog.V(4).Infof("Adding pod %s/%s to graph", pod.Namespace, pod.Name)

-		podNode := kubegraph.EnsurePodNode(g, pod)

-

-		addPodSpecToGraph(g, &pod.Spec, podNode)

-	}

-}

-

-// Edges are added to the graph from each predecessor (pod or replication

-// controller) to the images specified by the pod spec's list of containers, as

-// long as the image is managed by OpenShift.

-func addPodSpecToGraph(g graph.Graph, spec *kapi.PodSpec, predecessor gonum.Node) {

-	for j := range spec.Containers {

-		container := spec.Containers[j]

-

-		glog.V(4).Infof("Examining container image %q", container.Image)

-

-		ref, err := imageapi.ParseDockerImageReference(container.Image)

-		if err != nil {

-			utilruntime.HandleError(fmt.Errorf("unable to parse DockerImageReference %q: %v", container.Image, err))

-			continue

-		}

-

-		if len(ref.ID) == 0 {

-			glog.V(4).Infof("%q has no image ID", container.Image)

-			continue

-		}

-

-		imageNode := imagegraph.FindImage(g, ref.ID)

-		if imageNode == nil {

-			glog.Infof("Unable to find image %q in the graph", ref.ID)

-			continue

-		}

-

-		glog.V(4).Infof("Adding edge from pod to image")

-		g.AddEdge(predecessor, imageNode, ReferencedImageEdgeKind)

-	}

-}

-

-// addReplicationControllersToGraph adds replication controllers to the graph.

-//

-// Edges are added to the graph from each replication controller to the images

-// specified by its pod spec's list of containers, as long as the image is

-// managed by OpenShift.

-func addReplicationControllersToGraph(g graph.Graph, rcs *kapi.ReplicationControllerList) {

-	for i := range rcs.Items {

-		rc := &rcs.Items[i]

-		glog.V(4).Infof("Examining replication controller %s/%s", rc.Namespace, rc.Name)

-		rcNode := kubegraph.EnsureReplicationControllerNode(g, rc)

-		addPodSpecToGraph(g, &rc.Spec.Template.Spec, rcNode)

-	}

-}

-

-// addDeploymentConfigsToGraph adds deployment configs to the graph.

-//

-// Edges are added to the graph from each deployment config to the images

-// specified by its pod spec's list of containers, as long as the image is

-// managed by OpenShift.

-func addDeploymentConfigsToGraph(g graph.Graph, dcs *deployapi.DeploymentConfigList) {

-	for i := range dcs.Items {

-		dc := &dcs.Items[i]

-		glog.V(4).Infof("Examining DeploymentConfig %s/%s", dc.Namespace, dc.Name)

-		dcNode := deploygraph.EnsureDeploymentConfigNode(g, dc)

-		addPodSpecToGraph(g, &dc.Spec.Template.Spec, dcNode)

-	}

-}

-

-// addBuildConfigsToGraph adds build configs to the graph.

-//

-// Edges are added to the graph from each build config to the image specified by its strategy.from.

-func addBuildConfigsToGraph(g graph.Graph, bcs *buildapi.BuildConfigList) {

-	for i := range bcs.Items {

-		bc := &bcs.Items[i]

-		glog.V(4).Infof("Examining BuildConfig %s/%s", bc.Namespace, bc.Name)

-		bcNode := buildgraph.EnsureBuildConfigNode(g, bc)

-		addBuildStrategyImageReferencesToGraph(g, bc.Spec.Strategy, bcNode)

-	}

-}

-

-// addBuildsToGraph adds builds to the graph.

-//

-// Edges are added to the graph from each build to the image specified by its strategy.from.

-func addBuildsToGraph(g graph.Graph, builds *buildapi.BuildList) {

-	for i := range builds.Items {

-		build := &builds.Items[i]

-		glog.V(4).Infof("Examining build %s/%s", build.Namespace, build.Name)

-		buildNode := buildgraph.EnsureBuildNode(g, build)

-		addBuildStrategyImageReferencesToGraph(g, build.Spec.Strategy, buildNode)

-	}

-}

-

-// addBuildStrategyImageReferencesToGraph ads references from the build strategy's parent node to the image

-// the build strategy references.

-//

-// Edges are added to the graph from each predecessor (build or build config)

-// to the image specified by strategy.from, as long as the image is managed by

-// OpenShift.

-func addBuildStrategyImageReferencesToGraph(g graph.Graph, strategy buildapi.BuildStrategy, predecessor gonum.Node) {

-	from := buildutil.GetInputReference(strategy)

-	if from == nil {

-		glog.V(4).Infof("Unable to determine 'from' reference - skipping")

-		return

-	}

-

-	glog.V(4).Infof("Examining build strategy with from: %#v", from)

-

-	var imageID string

-

-	switch from.Kind {

-	case "ImageStreamImage":

-		_, id, err := imageapi.ParseImageStreamImageName(from.Name)

-		if err != nil {

-			glog.V(2).Infof("Error parsing ImageStreamImage name %q: %v - skipping", from.Name, err)

-			return

-		}

-		imageID = id

-	case "DockerImage":

-		ref, err := imageapi.ParseDockerImageReference(from.Name)

-		if err != nil {

-			glog.V(2).Infof("Error parsing DockerImage name %q: %v - skipping", from.Name, err)

-			return

-		}

-		imageID = ref.ID

-	default:

-		return

-	}

-

-	glog.V(4).Infof("Looking for image %q in graph", imageID)

-	imageNode := imagegraph.FindImage(g, imageID)

-	if imageNode == nil {

-		glog.V(4).Infof("Unable to find image %q in graph - skipping", imageID)

-		return

-	}

-

-	glog.V(4).Infof("Adding edge from %v to %v", predecessor, imageNode)

-	g.AddEdge(predecessor, imageNode, ReferencedImageEdgeKind)

-}

-

-// getImageNodes returns only nodes of type ImageNode.

-func getImageNodes(nodes []gonum.Node) []*imagegraph.ImageNode {

-	ret := []*imagegraph.ImageNode{}

-	for i := range nodes {

-		if node, ok := nodes[i].(*imagegraph.ImageNode); ok {

-			ret = append(ret, node)

-		}

-	}

-	return ret

-}

-

-// edgeKind returns true if the edge from "from" to "to" is of the desired kind.

-func edgeKind(g graph.Graph, from, to gonum.Node, desiredKind string) bool {