@@ -84,6 +84,14 @@ func (o *PruneBuildsOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command,

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

 	}

+	namespace := kapi.NamespaceAll

+	if cmd.Flags().Lookup("namespace").Changed {

+		var err error

+		namespace, _, err = f.DefaultNamespace()

+		if err != nil {

+			return err

+		}

+	}

 	o.Out = out

 	osClient, _, err := f.Clients()

@@ -92,7 +100,7 @@ func (o *PruneBuildsOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command,

 	}

 	o.Client = osClient

-	buildConfigList, err := osClient.BuildConfigs(kapi.NamespaceAll).List(kapi.ListOptions{})

+	buildConfigList, err := osClient.BuildConfigs(namespace).List(kapi.ListOptions{})

 	if err != nil {

 		return err

 	}

@@ -101,7 +109,7 @@ func (o *PruneBuildsOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command,

 		buildConfigs = append(buildConfigs, &buildConfigList.Items[i])

 	}

-	buildList, err := osClient.Builds(kapi.NamespaceAll).List(kapi.ListOptions{})

+	buildList, err := osClient.Builds(namespace).List(kapi.ListOptions{})

 	if err != nil {

 		return err

 	}

@@ -85,6 +85,14 @@ func (o *PruneDeploymentsOptions) Complete(f *clientcmd.Factory, cmd *cobra.Comm

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

 	}

+	namespace := kapi.NamespaceAll

+	if cmd.Flags().Lookup("namespace").Changed {

+		var err error

+		namespace, _, err = f.DefaultNamespace()

+		if err != nil {

+			return err

+		}

+	}

 	o.Out = out

 	osClient, kClient, err := f.Clients()

@@ -93,7 +101,7 @@ func (o *PruneDeploymentsOptions) Complete(f *clientcmd.Factory, cmd *cobra.Comm

 	}

 	o.Client = kClient

-	deploymentConfigList, err := osClient.DeploymentConfigs(kapi.NamespaceAll).List(kapi.ListOptions{})

+	deploymentConfigList, err := osClient.DeploymentConfigs(namespace).List(kapi.ListOptions{})

 	if err != nil {

 		return err

 	}

@@ -102,7 +110,7 @@ func (o *PruneDeploymentsOptions) Complete(f *clientcmd.Factory, cmd *cobra.Comm

 		deploymentConfigs = append(deploymentConfigs, &deploymentConfigList.Items[i])

 	}

-	deploymentList, err := kClient.ReplicationControllers(kapi.NamespaceAll).List(kapi.ListOptions{})

+	deploymentList, err := kClient.ReplicationControllers(namespace).List(kapi.ListOptions{})

 	if err != nil {

 		return err

 	}

@@ -124,7 +124,14 @@ func (o *PruneImagesOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command,

 	if !cmd.Flags().Lookup("prune-over-size-limit").Changed {

 		o.PruneOverSizeLimit = nil

 	}

-

+	namespace := kapi.NamespaceAll

+	if cmd.Flags().Lookup("namespace").Changed {

+		var err error

+		namespace, _, err = f.DefaultNamespace()

+		if err != nil {

+			return err

+		}

+	}

 	o.Out = out

 	osClient, kClient, registryClient, err := getClients(f, o.CABundle)

@@ -138,41 +145,41 @@ func (o *PruneImagesOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command,

 		return err

 	}

-	allStreams, err := osClient.ImageStreams(kapi.NamespaceAll).List(kapi.ListOptions{})

+	allStreams, err := osClient.ImageStreams(namespace).List(kapi.ListOptions{})

 	if err != nil {

 		return err

 	}

-	allPods, err := kClient.Pods(kapi.NamespaceAll).List(kapi.ListOptions{})

+	allPods, err := kClient.Pods(namespace).List(kapi.ListOptions{})

 	if err != nil {

 		return err

 	}

-	allRCs, err := kClient.ReplicationControllers(kapi.NamespaceAll).List(kapi.ListOptions{})

+	allRCs, err := kClient.ReplicationControllers(namespace).List(kapi.ListOptions{})

 	if err != nil {

 		return err

 	}

-	allBCs, err := osClient.BuildConfigs(kapi.NamespaceAll).List(kapi.ListOptions{})

+	allBCs, err := osClient.BuildConfigs(namespace).List(kapi.ListOptions{})

 	// We need to tolerate 'not found' errors for buildConfigs since they may be disabled in Atomic

 	err = oserrors.TolerateNotFoundError(err)

 	if err != nil {

 		return err

 	}

-	allBuilds, err := osClient.Builds(kapi.NamespaceAll).List(kapi.ListOptions{})

+	allBuilds, err := osClient.Builds(namespace).List(kapi.ListOptions{})

 	// We need to tolerate 'not found' errors for builds since they may be disabled in Atomic

 	err = oserrors.TolerateNotFoundError(err)

 	if err != nil {

 		return err

 	}

-	allDCs, err := osClient.DeploymentConfigs(kapi.NamespaceAll).List(kapi.ListOptions{})

+	allDCs, err := osClient.DeploymentConfigs(namespace).List(kapi.ListOptions{})

 	if err != nil {

 		return err

 	}

-	limitRangesList, err := kClient.LimitRanges(kapi.NamespaceAll).List(kapi.ListOptions{})

+	limitRangesList, err := kClient.LimitRanges(namespace).List(kapi.ListOptions{})

 	if err != nil {

 		return err

 	}

@@ -203,6 +210,9 @@ func (o *PruneImagesOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command,

 		RegistryClient:     registryClient,

 		RegistryURL:        o.RegistryUrlOverride,

 	}

+	if namespace != kapi.NamespaceAll {

+		options.Namespace = namespace

+	}

 	o.Pruner = prune.NewPruner(options)

@@ -54,6 +54,7 @@ type pruneAlgorithm struct {

 	keepYoungerThan    time.Duration

 	keepTagRevisions   int

 	pruneOverSizeLimit bool

+	namespace          string

 }

 // ImageDeleter knows how to remove images from OpenShift.

@@ -102,6 +103,8 @@ type PrunerOptions struct {

 	// PruneOverSizeLimit indicates that images exceeding defined limits (openshift.io/Image)

 	// will be considered as candidates for pruning.

 	PruneOverSizeLimit *bool

+	// Namespace to be pruned, if specified it should never remove Images.

+	Namespace string

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

@@ -256,6 +259,7 @@ func NewPruner(options PrunerOptions) Pruner {

 	if options.PruneOverSizeLimit != nil {

 		algorithm.pruneOverSizeLimit = *options.PruneOverSizeLimit

 	}

+	algorithm.namespace = options.Namespace

 	addImagesToGraph(g, options.Images, algorithm)

 	addImageStreamsToGraph(g, options.Streams, options.LimitRanges, algorithm)

@@ -819,12 +823,16 @@ func (p *pruner) Prune(

 	}

 	prunableImageNodes, prunableImageIDs := calculatePrunableImages(p.g, imageNodes)

-	graphWithoutPrunableImages := subgraphWithoutPrunableImages(p.g, prunableImageIDs)

-	prunableComponents := calculatePrunableImageComponents(graphWithoutPrunableImages)

 	errs := []error{}

-

 	errs = append(errs, pruneStreams(p.g, prunableImageNodes, streamPruner)...)

+	// if namespace is specified prune only ImageStreams and nothing more

+	if len(p.algorithm.namespace) > 0 {

+		return kerrors.NewAggregate(errs)

+	}

+

+	graphWithoutPrunableImages := subgraphWithoutPrunableImages(p.g, prunableImageIDs)

+	prunableComponents := calculatePrunableImageComponents(graphWithoutPrunableImages)

 	errs = append(errs, pruneImageComponents(p.g, p.registryClient, registryURL, prunableComponents, layerLinkPruner)...)

 	errs = append(errs, pruneBlobs(p.g, p.registryClient, registryURL, prunableComponents, blobPruner)...)

 	errs = append(errs, pruneManifests(p.g, p.registryClient, registryURL, prunableImageNodes, manifestPruner)...)

@@ -418,6 +418,7 @@ func TestImagePruning(t *testing.T) {

 	tests := map[string]struct {

 		pruneOverSizeLimit         *bool

 		registryURLs               []string

+		namespace                  string

 		images                     imageapi.ImageList

 		pods                       kapi.PodList

 		streams                    imageapi.ImageStreamList

@@ -870,6 +871,28 @@ func TestImagePruning(t *testing.T) {

 			expectedImageDeletions: []string{},

 			expectedStreamUpdates:  []string{},

 		},

+		"image exceeding limits with namespace specified": {

+			pruneOverSizeLimit: newBool(true),

+			namespace:          "foo",

+			images: imageList(

+				unmanagedImage("id", "otherregistry/foo/bar@id", false, "", ""),

+				sizedImage("id2", registryURL+"/foo/bar@id2", 100, nil),

+				sizedImage("id3", registryURL+"/foo/bar@id3", 200, nil),

+			),

+			streams: streamList(

+				stream(registryURL, "foo", "bar", tags(

+					tag("latest",

+						tagEvent("id", "otherregistry/foo/bar@id"),

+						tagEvent("id2", registryURL+"/foo/bar@id2"),

+						tagEvent("id3", registryURL+"/foo/bar@id3"),

+					),

+				)),

+			),

+			limits: map[string][]*kapi.LimitRange{

+				"foo": limitList(100, 200),

+			},

+			expectedStreamUpdates: []string{"foo/bar|id3"},

+		},

 	}

 	for name, test := range tests {

@@ -879,6 +902,7 @@ func TestImagePruning(t *testing.T) {

 		}

 		options := PrunerOptions{

+			Namespace:   test.namespace,

 			Images:      &test.images,

 			Streams:     &test.streams,

 			Pods:        &test.pods,