add namespace param for fn and env (#2556)

This PR moves fission CLI as closer as possible to kubectl command behaviour.  We have improved namespace handling behaviour across CLI.

* add namespace param for fn and env
* use common fn for ns check
* update validation
* default namespace for httpTrigger, env and package, config and triggers
* use default ns
* add namespace filter to spec
* add forceNamespace flag
* set current namespace
* add default namespace in config
* add namespace specific destroy
* add all namespace in the list of resources
* add namespace as global tag
* use %s instead of %v
* add test cases for namespace
* use ns in get all functions

pkg/fission-cli/cmd/spec/apply.go

@@ -62,6 +62,67 @@ func Apply(input cli.Input) error {
 
 func (opts *ApplySubCommand) do(input cli.Input) error {
 	return opts.run(input)
+
+}
+
+// insertNamespace inserts the Namespace value if it was not provided at the time of `spec save`.
+// we make sure that all component of a resource should be present in the same Namespace. i.e.
+// Function's env and package should be present in same namespace
+func (opts *ApplySubCommand) insertNamespace(input cli.Input, fr *FissionResources) error {
+
+	result := utils.MultiErrorWithFormat()
+	_, currentNS, err := util.GetResourceNamespace(input, flagkey.NamespaceEnvironment)
+	if err != nil {
+		return fv1.AggregateValidationErrors("Environment", err)
+	}
+
+	for i := range fr.Functions {
+		if fr.Functions[i].Namespace == "" || input.Bool(flagkey.ForceNamespace) {
+			fr.Functions[i].Namespace = currentNS
+			fr.Functions[i].Spec.Package.PackageRef.Namespace = currentNS
+			fr.Functions[i].Spec.Environment.Namespace = currentNS
+			for j := range fr.Functions[i].Spec.ConfigMaps {
+				fr.Functions[i].Spec.ConfigMaps[j].Namespace = currentNS
+			}
+			for j := range fr.Functions[i].Spec.Secrets {
+				fr.Functions[i].Spec.Secrets[j].Namespace = currentNS
+			}
+		}
+	}
+	for i := range fr.Environments {
+		if fr.Environments[i].Namespace == "" || input.Bool(flagkey.ForceNamespace) {
+			fr.Environments[i].Namespace = currentNS
+		}
+	}
+	for i := range fr.Packages {
+		if fr.Packages[i].Namespace == "" || input.Bool(flagkey.ForceNamespace) {
+			fr.Packages[i].Namespace = currentNS
+			fr.Packages[i].Spec.Environment.Namespace = currentNS
+			fr.Packages[i].ObjectMeta.Namespace = currentNS
+		}
+	}
+	for i := range fr.HttpTriggers {
+		if fr.HttpTriggers[i].Namespace == "" || input.Bool(flagkey.ForceNamespace) {
+			fr.HttpTriggers[i].Namespace = currentNS
+		}
+	}
+	for i := range fr.MessageQueueTriggers {
+		if fr.MessageQueueTriggers[i].Namespace == "" || input.Bool(flagkey.ForceNamespace) {
+			fr.MessageQueueTriggers[i].Namespace = currentNS
+		}
+	}
+	for i := range fr.TimeTriggers {
+		if fr.TimeTriggers[i].Namespace == "" || input.Bool(flagkey.ForceNamespace) {
+			fr.TimeTriggers[i].Namespace = currentNS
+		}
+	}
+	for i := range fr.KubernetesWatchTriggers {
+		if fr.KubernetesWatchTriggers[i].Namespace == "" || input.Bool(flagkey.ForceNamespace) {
+			fr.KubernetesWatchTriggers[i].Namespace = currentNS
+		}
+	}
+
+	return result.ErrorOrNil()
 }
 
 func (opts *ApplySubCommand) run(input cli.Input) error {
@@ -117,8 +178,13 @@ func (opts *ApplySubCommand) run(input cli.Input) error {
 			return errors.Wrap(err, "error reading specs")
 		}
 
+		err = opts.insertNamespace(input, fr)
+		if err != nil {
+			return errors.Wrap(err, "error reading specs")
+		}
+
 		if validateSpecs {
-			err = Validate(input)
+			err = validateForApply(input, fr)
 			if err != nil {
 				return errors.Wrap(err, "abort applying resources")
 			}
@@ -616,6 +682,7 @@ func applyPackages(fclient client.Interface, fr *FissionResources, delete bool,
 	for _, o := range fr.Packages {
 		// apply deploymentConfig so we can find our objects on future apply invocations
 		applyDeploymentConfig(&o.ObjectMeta, fr)
+		console.Verbose(2, fmt.Sprintf("Package is here '%s','%s','%s','%s'", o.Namespace, o.Name, o.Spec.Environment.Namespace, o.Spec.Environment.Name))
 
 		// index desired state
 		desired[mapKey(&o.ObjectMeta)] = true

pkg/fission-cli/cmd/spec/command.go

@@ -48,7 +48,8 @@ func Commands() *cobra.Command {
 		RunE:  wrapper.Wrapper(Apply),
 	}
 	wrapper.SetFlags(applyCmd, flag.FlagSet{
-		Optional: []flag.Flag{flag.SpecDir, flag.SpecIgnore, flag.SpecDelete, flag.SpecWait, flag.SpecWatch, flag.SpecValidation, flag.SpecApplyCommitLabel, flag.SpecAllowConflicts},
+		Optional: []flag.Flag{flag.SpecDir, flag.SpecIgnore, flag.SpecDelete, flag.SpecWait, flag.SpecWatch,
+			flag.SpecValidation, flag.SpecApplyCommitLabel, flag.SpecAllowConflicts, flag.ForceNamespace},
 	})
 
 	destroyCmd := &cobra.Command{
@@ -57,7 +58,7 @@ func Commands() *cobra.Command {
 		RunE:  wrapper.Wrapper(Destroy),
 	}
 	wrapper.SetFlags(destroyCmd, flag.FlagSet{
-		Optional: []flag.Flag{flag.SpecDir, flag.SpecIgnore},
+		Optional: []flag.Flag{flag.SpecDir, flag.SpecIgnore, flag.ForceDelete},
 	})
 
 	listCmd := &cobra.Command{
@@ -66,7 +67,7 @@ func Commands() *cobra.Command {
 		RunE:  wrapper.Wrapper(List),
 	}
 	wrapper.SetFlags(listCmd, flag.FlagSet{
-		Optional: []flag.Flag{flag.SpecDeployID, flag.SpecDir, flag.SpecIgnore},
+		Optional: []flag.Flag{flag.SpecDeployID, flag.SpecDir, flag.SpecIgnore, flag.AllNamespaces},
 	})
 
 	command := &cobra.Command{

pkg/fission-cli/cmd/spec/destroy.go

@@ -17,12 +17,19 @@ limitations under the License.
 package spec
 
 import (
+	"fmt"
+	"strings"
+
 	"github.com/pkg/errors"
 
+	fv1 "github.com/fission/fission/pkg/apis/core/v1"
 	"github.com/fission/fission/pkg/controller/client"
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
 	"github.com/fission/fission/pkg/fission-cli/cmd"
+	"github.com/fission/fission/pkg/fission-cli/console"
+	flagkey "github.com/fission/fission/pkg/fission-cli/flag/key"
 	"github.com/fission/fission/pkg/fission-cli/util"
+	"github.com/fission/fission/pkg/utils"
 )
 
 type DestroySubCommand struct {
@@ -49,12 +56,26 @@ func (opts *DestroySubCommand) run(input cli.Input) error {
 		return errors.Wrap(err, "error reading specs")
 	}
 
-	// set desired state to nothing, but keep the UID so "apply" can find it
-	emptyFr := FissionResources{}
-	emptyFr.DeploymentConfig = fr.DeploymentConfig
+	if !input.Bool(flagkey.ForceDelete) {
+		err = opts.insertNSToResource(input, fr)
+		if err != nil {
+			return errors.Wrap(err, "error adding namespace")
+		}
+	} else {
+		// if force delete set to true we fetch all resources with our deployment ID and delete them
+		// set desired state to nothing, but keep the UID so "apply" can find it
+		emptyFr := FissionResources{}
+		emptyFr.DeploymentConfig = fr.DeploymentConfig
 
-	// "apply" the empty state
-	err = deleteResources(opts.Client(), &emptyFr)
+		// "apply" the empty state
+		err = forceDeleteResources(opts.Client(), &emptyFr)
+		if err != nil {
+			return errors.Wrap(err, "error deleting resources")
+		}
+		return nil
+	}
+	forceDelete := input.Bool(flagkey.ForceDelete)
+	err = deleteResources(opts.Client(), fr, forceDelete)
 	if err != nil {
 		return errors.Wrap(err, "error deleting resources")
 	}
@@ -62,7 +83,7 @@ func (opts *DestroySubCommand) run(input cli.Input) error {
 	return nil
 }
 
-func deleteResources(fclient client.Interface, fr *FissionResources) error {
+func forceDeleteResources(fclient client.Interface, fr *FissionResources) error {
 
 	var err error
 
@@ -103,3 +124,219 @@ func deleteResources(fclient client.Interface, fr *FissionResources) error {
 
 	return nil
 }
+
+// insertNSToResource provides a namespace to all resource which don't have a namespace specified
+// in resource
+func (opts *DestroySubCommand) insertNSToResource(input cli.Input, fr *FissionResources) error {
+
+	result := utils.MultiErrorWithFormat()
+
+	_, currentNS, err := util.GetResourceNamespace(input, flagkey.NamespaceEnvironment)
+	if err != nil {
+		return fv1.AggregateValidationErrors("Environment", err)
+	}
+
+	for i := range fr.Functions {
+		if fr.Functions[i].Namespace == "" {
+			fr.Functions[i].Namespace = currentNS
+		}
+	}
+	for i := range fr.Environments {
+		if fr.Environments[i].Namespace == "" {
+			fr.Environments[i].Namespace = currentNS
+		}
+	}
+	for i := range fr.Packages {
+		if fr.Packages[i].Namespace == "" {
+			fr.Packages[i].Namespace = currentNS
+		}
+	}
+	for i := range fr.HttpTriggers {
+		if fr.HttpTriggers[i].Namespace == "" {
+			fr.HttpTriggers[i].Namespace = currentNS
+		}
+	}
+	for i := range fr.MessageQueueTriggers {
+		if fr.MessageQueueTriggers[i].Namespace == "" {
+			fr.MessageQueueTriggers[i].Namespace = currentNS
+		}
+	}
+	for i := range fr.TimeTriggers {
+		if fr.TimeTriggers[i].Namespace == "" {
+			fr.TimeTriggers[i].Namespace = currentNS
+		}
+	}
+	for i := range fr.KubernetesWatchTriggers {
+		if fr.KubernetesWatchTriggers[i].Namespace == "" {
+			fr.KubernetesWatchTriggers[i].Namespace = currentNS
+		}
+	}
+
+	return result.ErrorOrNil()
+}
+
+func deleteResources(fclient client.Interface, fr *FissionResources, forceDelete bool) error {
+
+	var err error
+
+	err = destroyHTTPTriggers(fclient, fr)
+	if err != nil {
+		return errors.Wrap(err, "HTTPTrigger delete failed")
+	}
+
+	err = destroyKubernetesWatchTriggers(fclient, fr)
+	if err != nil {
+		return errors.Wrap(err, "KubernetesWatchTrigger delete failed")
+	}
+
+	err = destroyTimeTriggers(fclient, fr)
+	if err != nil {
+		return errors.Wrap(err, "TimeTrigger delete failed")
+	}
+
+	err = destroyMessageQueueTriggers(fclient, fr)
+	if err != nil {
+		return errors.Wrap(err, "MessageQueueTrigger delete failed")
+	}
+
+	err = destroyFunctions(fclient, fr)
+	if err != nil {
+		return errors.Wrap(err, "function delete failed")
+	}
+
+	err = destroyPackages(fclient, fr)
+	if err != nil {
+		return errors.Wrap(err, "package delete failed")
+	}
+
+	err = destroyEnvironments(fclient, fr)
+	if err != nil {
+		return errors.Wrap(err, "environment delete failed")
+	}
+
+	return nil
+}
+
+func destroyHTTPTriggers(fclient client.Interface, fr *FissionResources) error {
+	for _, o := range fr.HttpTriggers {
+		err := fclient.V1().HTTPTrigger().Delete(&o.ObjectMeta)
+		if err != nil && strings.Contains(err.Error(), "not found") {
+			console.Verbose(2, fmt.Sprintf("could not delete httptrigger: %s Namespace: %s", o.ObjectMeta.Name, o.ObjectMeta.Namespace))
+			err = nil
+			continue
+
+		} else if err != nil {
+			return err
+		}
+		fmt.Printf("Deleted %s %s/%s\n", o.TypeMeta.Kind, o.ObjectMeta.Namespace, o.ObjectMeta.Name)
+	}
+	return nil
+}
+
+func destroyKubernetesWatchTriggers(fclient client.Interface, fr *FissionResources) error {
+
+	for _, o := range fr.KubernetesWatchTriggers {
+		err := fclient.V1().KubeWatcher().Delete(&o.ObjectMeta)
+		if err != nil && strings.Contains(err.Error(), "not found") {
+			console.Verbose(2, fmt.Sprintf("could not delete watch: %s Namespace: %s", o.ObjectMeta.Name, o.ObjectMeta.Namespace))
+			err = nil
+			continue
+
+		} else if err != nil {
+			return err
+		}
+		fmt.Printf("Deleted %s %s/%s\n", o.TypeMeta.Kind, o.ObjectMeta.Namespace, o.ObjectMeta.Name)
+	}
+
+	return nil
+}
+
+func destroyTimeTriggers(fclient client.Interface, fr *FissionResources) error {
+
+	for _, o := range fr.TimeTriggers {
+		err := fclient.V1().TimeTrigger().Delete(&o.ObjectMeta)
+		if err != nil && strings.Contains(err.Error(), "not found") {
+			console.Verbose(2, fmt.Sprintf("could not delete Time trigger: %s Namespace: %s", o.ObjectMeta.Name, o.ObjectMeta.Namespace))
+			err = nil
+			continue
+
+		} else if err != nil {
+			return err
+		}
+		fmt.Printf("Deleted %s %s/%s\n", o.TypeMeta.Kind, o.ObjectMeta.Namespace, o.ObjectMeta.Name)
+	}
+
+	return nil
+}
+
+func destroyMessageQueueTriggers(fclient client.Interface, fr *FissionResources) error {
+
+	for _, o := range fr.MessageQueueTriggers {
+		err := fclient.V1().MessageQueueTrigger().Delete(&o.ObjectMeta)
+		if err != nil && strings.Contains(err.Error(), "not found") {
+			console.Verbose(2, fmt.Sprintf("could not delete Message trigger: %s Namespace: %s", o.ObjectMeta.Name, o.ObjectMeta.Namespace))
+			err = nil
+			continue
+
+		} else if err != nil {
+			return err
+		}
+		fmt.Printf("Deleted %s %s/%s\n", o.TypeMeta.Kind, o.ObjectMeta.Namespace, o.ObjectMeta.Name)
+	}
+
+	return nil
+}
+
+func destroyFunctions(fclient client.Interface, fr *FissionResources) error {
+
+	for _, o := range fr.Functions {
+		err := fclient.V1().Function().Delete(&o.ObjectMeta)
+		if err != nil && strings.Contains(err.Error(), "not found") {
+			console.Verbose(2, fmt.Sprintf("could not delete Functions: %s Namespace: %s", o.ObjectMeta.Name, o.ObjectMeta.Namespace))
+			err = nil
+			continue
+
+		} else if err != nil {
+			return err
+		}
+		fmt.Printf("Deleted %s %s/%s\n", o.TypeMeta.Kind, o.ObjectMeta.Namespace, o.ObjectMeta.Name)
+	}
+
+	return nil
+}
+
+func destroyPackages(fclient client.Interface, fr *FissionResources) error {
+
+	for _, o := range fr.Packages {
+		err := fclient.V1().Package().Delete(&o.ObjectMeta)
+		if err != nil && strings.Contains(err.Error(), "not found") {
+			console.Verbose(2, fmt.Sprintf("could not delete Package: %s Namespace: %s", o.ObjectMeta.Name, o.ObjectMeta.Namespace))
+			err = nil
+			continue
+
+		} else if err != nil {
+			return err
+		}
+		fmt.Printf("Deleted %s %s/%s\n", o.TypeMeta.Kind, o.ObjectMeta.Namespace, o.ObjectMeta.Name)
+	}
+
+	return nil
+}
+
+func destroyEnvironments(fclient client.Interface, fr *FissionResources) error {
+
+	for _, o := range fr.Environments {
+		err := fclient.V1().Environment().Delete(&o.ObjectMeta)
+		if err != nil && strings.Contains(err.Error(), "not found") {
+			console.Verbose(2, fmt.Sprintf("could not delete Env: %s Namespace: %s", o.ObjectMeta.Name, o.ObjectMeta.Namespace))
+			err = nil
+			continue
+
+		} else if err != nil {
+			return err
+		}
+		fmt.Printf("Deleted %s %s/%s\n", o.TypeMeta.Kind, o.ObjectMeta.Namespace, o.ObjectMeta.Name)
+	}
+
+	return nil
+}

pkg/fission-cli/cmd/spec/list.go

@@ -60,63 +60,90 @@ func (opts *ListSubCommand) run(input cli.Input) error {
 		deployID = fr.DeploymentConfig.UID
 	}
 
-	allfn, err := getAllFunctions(opts.Client())
+	_, currentNS, err := util.GetResourceNamespace(input, flagkey.NamespaceEnvironment)
 	if err != nil {
-		return errors.Wrap(err, "error getting Functions from all namespaces")
+		return fv1.AggregateValidationErrors("Environment", err)
+	}
+
+	if input.Bool(flagkey.AllNamespaces) {
+		return opts.getResource(input, "", deployID)
+	} else {
+		return opts.getResource(input, currentNS, deployID)
+	}
+
+}
+
+func (opts *ListSubCommand) getResource(input cli.Input, namespace string, deployID string) (err error) {
+	var allfn []fv1.Function
+	printNS := namespace
+	if printNS == "" {
+		printNS = "all"
+	}
+
+	allfn, err = getAllFunctions(opts.Client(), namespace)
+	if err != nil {
+		return errors.Wrap(err, fmt.Sprintf("error getting Functions from %s namespaces", printNS))
 	}
 	specfns := getAppliedFunctions(allfn, deployID)
 	ShowFunctions(specfns)
 
-	allenvs, err := getAllEnvironments(opts.Client())
+	var allenvs []fv1.Environment
+	allenvs, err = getAllEnvironments(opts.Client(), namespace)
 	if err != nil {
-		return errors.Wrap(err, "error getting Environments from all namespaces")
+		return errors.Wrap(err, fmt.Sprintf("error getting Environments from  %s namespaces", printNS))
 	}
 	specenvs := getAppliedEnvironments(allenvs, deployID)
 	ShowEnvironments(specenvs)
 
-	pkglists, err := getAllPackages(opts.Client())
+	var pkglists []fv1.Package
+	pkglists, err = getAllPackages(opts.Client(), namespace)
 	if err != nil {
-		return errors.Wrap(err, "error getting Packages from all namespaces")
+		return errors.Wrap(err, fmt.Sprintf("error getting Packages from  %s namespaces", printNS))
 	}
 	specPkgs := getAppliedPackages(pkglists, deployID)
 	ShowPackages(specPkgs)
 
-	canaryCfgs, err := getAllCanaryConfigs(opts.Client())
+	var canaryCfgs []fv1.CanaryConfig
+	canaryCfgs, err = getAllCanaryConfigs(opts.Client(), namespace)
 	if err != nil {
-		return errors.Wrap(err, "error getting Canary Config from all namespaces")
+		return errors.Wrap(err, fmt.Sprintf("error getting Canary Config from  %s namespaces", printNS))
 	}
 	specCanaryCfgs := getAppliedCanaryConfigs(canaryCfgs, deployID)
 	ShowCanaryConfigs(specCanaryCfgs)
 
-	hts, err := getAllHTTPTriggers(opts.Client())
+	var hts []fv1.HTTPTrigger
+	hts, err = getAllHTTPTriggers(opts.Client(), namespace)
 	if err != nil {
-		return errors.Wrap(err, "error getting HTTP Triggers from all namespaces")
+		return errors.Wrap(err, fmt.Sprintf("error getting HTTP Triggers from  %s namespaces", printNS))
 	}
 	specHTTPTriggers := getAppliedHTTPTriggers(hts, deployID)
 	ShowHTTPTriggers(specHTTPTriggers)
 
-	mqts, err := getAllMessageQueueTriggers(opts.Client(), input.String(flagkey.MqtMQType))
+	var mqts []fv1.MessageQueueTrigger
+	mqts, err = getAllMessageQueueTriggers(opts.Client(), input.String(flagkey.MqtMQType), namespace)
 	if err != nil {
-		return errors.Wrap(err, "error getting MessageQueue Triggers from all namespaces")
+		return errors.Wrap(err, fmt.Sprintf("error getting MessageQueue Triggers from  %s namespaces", printNS))
 	}
 	specMessageQueueTriggers := getAppliedMessageQueueTriggers(mqts, deployID)
 	ShowMQTriggers(specMessageQueueTriggers)
 
-	tts, err := getAllTimeTriggers(opts.Client())
+	var tts []fv1.TimeTrigger
+	tts, err = getAllTimeTriggers(opts.Client(), namespace)
 	if err != nil {
-		return errors.Wrap(err, "error getting Time Triggers from all namespaces")
+		return errors.Wrap(err, fmt.Sprintf("error getting Time Triggers from  %s namespaces", printNS))
 	}
 	specTimeTriggers := getAppliedTimeTriggers(tts, deployID)
 	ShowTimeTriggers(specTimeTriggers)
 
-	kws, err := getAllKubeWatchTriggers(opts.Client())
+	var kws []fv1.KubernetesWatchTrigger
+	kws, err = getAllKubeWatchTriggers(opts.Client(), namespace)
 	if err != nil {
-		return errors.Wrap(err, "error getting Kube Watchers from all namespaces")
+		return errors.Wrap(err, fmt.Sprintf("error getting Kube Watchers from  %s namespaces", printNS))
 	}
 	specKubeWatchers := getSpecKubeWatchers(kws, deployID)
 	ShowAppliedKubeWatchers(specKubeWatchers)
 
-	return nil
+	return err
 }
 
 func getAppliedFunctions(fns []fv1.Function, deployID string) []fv1.Function {
@@ -392,9 +419,9 @@ func ShowAppliedKubeWatchers(ws []fv1.KubernetesWatchTrigger) {
 	}
 }
 
-// getAllFunctions get lists of functions in all namespaces
-func getAllFunctions(client client.Interface) ([]fv1.Function, error) {
-	fns, err := client.V1().Function().List("")
+// getAllFunctions get lists of functions in provided namespaces
+func getAllFunctions(client client.Interface, namespace string) ([]fv1.Function, error) {
+	fns, err := client.V1().Function().List(namespace)
 	if err != nil {
 		return nil, errors.Errorf("Unable to get Functions %v", err.Error())
 	}
@@ -402,8 +429,8 @@ func getAllFunctions(client client.Interface) ([]fv1.Function, error) {
 }
 
 // getAllEnvironments get lists of environments in all namespaces
-func getAllEnvironments(client client.Interface) ([]fv1.Environment, error) {
-	envs, err := client.V1().Environment().List("")
+func getAllEnvironments(client client.Interface, namespace string) ([]fv1.Environment, error) {
+	envs, err := client.V1().Environment().List(namespace)
 	if err != nil {
 		return nil, errors.Errorf("Unable to get Environments %v", err.Error())
 	}
@@ -411,8 +438,8 @@ func getAllEnvironments(client client.Interface) ([]fv1.Environment, error) {
 }
 
 // getAllPackages get lists of packages in all namespaces
-func getAllPackages(client client.Interface) ([]fv1.Package, error) {
-	pkgList, err := client.V1().Package().List("")
+func getAllPackages(client client.Interface, namespace string) ([]fv1.Package, error) {
+	pkgList, err := client.V1().Package().List(namespace)
 	if err != nil {
 		return nil, errors.Errorf("Unable to get Packages %v", err.Error())
 	}
@@ -420,8 +447,8 @@ func getAllPackages(client client.Interface) ([]fv1.Package, error) {
 }
 
 // getAllCanaryConfigs get lists of canary configs in all namespaces
-func getAllCanaryConfigs(client client.Interface) ([]fv1.CanaryConfig, error) {
-	canaryCfgs, err := client.V1().CanaryConfig().List("")
+func getAllCanaryConfigs(client client.Interface, namespace string) ([]fv1.CanaryConfig, error) {
+	canaryCfgs, err := client.V1().CanaryConfig().List(namespace)
 	if err != nil {
 		return nil, errors.Errorf("Unable to get Canary Configs %v", err.Error())
 	}
@@ -429,8 +456,8 @@ func getAllCanaryConfigs(client client.Interface) ([]fv1.CanaryConfig, error) {
 }
 
 // getAllHTTPTriggers get lists of HTTP Triggers in all namespaces
-func getAllHTTPTriggers(client client.Interface) ([]fv1.HTTPTrigger, error) {
-	hts, err := client.V1().HTTPTrigger().List("")
+func getAllHTTPTriggers(client client.Interface, namespace string) ([]fv1.HTTPTrigger, error) {
+	hts, err := client.V1().HTTPTrigger().List(namespace)
 	if err != nil {
 		return nil, errors.Errorf("Unable to get HTTP Triggers %v", err.Error())
 	}
@@ -438,8 +465,8 @@ func getAllHTTPTriggers(client client.Interface) ([]fv1.HTTPTrigger, error) {
 }
 
 // getAllMessageQueueTriggers get lists of MessageQueue Triggers in all namespaces
-func getAllMessageQueueTriggers(client client.Interface, mqttype string) ([]fv1.MessageQueueTrigger, error) {
-	mqts, err := client.V1().MessageQueueTrigger().List(mqttype, "")
+func getAllMessageQueueTriggers(client client.Interface, mqttype string, namespace string) ([]fv1.MessageQueueTrigger, error) {
+	mqts, err := client.V1().MessageQueueTrigger().List(mqttype, namespace)
 	if err != nil {
 		return nil, errors.Errorf("Unable to get MessageQueue Triggers %v", err.Error())
 	}
@@ -447,8 +474,8 @@ func getAllMessageQueueTriggers(client client.Interface, mqttype string) ([]fv1.
 }
 
 // getAllTimeTriggers get lists of Time Triggers in all namespaces
-func getAllTimeTriggers(client client.Interface) ([]fv1.TimeTrigger, error) {
-	tts, err := client.V1().TimeTrigger().List("")
+func getAllTimeTriggers(client client.Interface, namespace string) ([]fv1.TimeTrigger, error) {
+	tts, err := client.V1().TimeTrigger().List(namespace)
 	if err != nil {
 		return nil, errors.Errorf("Unable to get Time Triggers %v", err.Error())
 	}
@@ -456,8 +483,8 @@ func getAllTimeTriggers(client client.Interface) ([]fv1.TimeTrigger, error) {
 }
 
 // getAllKubeWatchTriggers get lists of Kube Watchers in all namespaces
-func getAllKubeWatchTriggers(client client.Interface) ([]fv1.KubernetesWatchTrigger, error) {
-	ws, err := client.V1().KubeWatcher().List("")
+func getAllKubeWatchTriggers(client client.Interface, namespace string) ([]fv1.KubernetesWatchTrigger, error) {
+	ws, err := client.V1().KubeWatcher().List(namespace)
 	if err != nil {
 		return nil, errors.Errorf("Unable to get Kube Watchers %v", err.Error())
 	}

pkg/fission-cli/cmd/spec/spec.go

@@ -491,7 +491,7 @@ func (fr *FissionResources) Validate(input cli.Input) ([]string, error) {
 
 	for _, f := range fr.Functions {
 		if _, ok := environments[fmt.Sprintf("%s:%s", f.Spec.Environment.Name, f.Spec.Environment.Namespace)]; !ok {
-			warnings = append(warnings, "Environment %s is referenced in function %s but not declared in specs", f.Spec.Environment.Name, f.ObjectMeta.Name)
+			warnings = append(warnings, fmt.Sprintf("Environment %s is referenced in function %s but not declared in specs", f.Spec.Environment.Name, f.ObjectMeta.Name))
 		}
 		strategy := f.Spec.InvokeStrategy.ExecutionStrategy
 		if strategy.ExecutorType == fv1.ExecutorTypeNewdeploy && strategy.SpecializationTimeout < fv1.DefaultSpecializationTimeOut {

pkg/fission-cli/cmd/spec/validate.go

@@ -48,17 +48,29 @@ func Validate(input cli.Input) error {
 }
 
 func (opts *ValidateSubCommand) do(input cli.Input) error {
-	return opts.run(input)
+	return opts.run(input, nil)
 }
 
-func (opts *ValidateSubCommand) run(input cli.Input) error {
+func validateForApply(input cli.Input, fr *FissionResources) error {
+
+	return (&ValidateSubCommand{}).doValidateForApply(input, fr)
+}
+func (opts *ValidateSubCommand) doValidateForApply(input cli.Input, fr *FissionResources) error {
+	return opts.run(input, fr)
+}
+
+func (opts *ValidateSubCommand) run(input cli.Input, fr *FissionResources) (err error) {
 
 	// this will error on parse errors and on duplicates
 	specDir := util.GetSpecDir(input)
 	specIgnore := util.GetSpecIgnore(input)
-	fr, err := ReadSpecs(specDir, specIgnore, false)
-	if err != nil {
-		return errors.Wrap(err, "error reading specs")
+
+	// If the call for validate is from apply spec we already have a parsed fission resource
+	if fr == nil {
+		fr, err = ReadSpecs(specDir, specIgnore, false)
+		if err != nil {
+			return errors.Wrap(err, "error reading specs")
+		}
 	}
 
 	console.Infof("DeployUID: %v", fr.DeploymentConfig.UID)
@@ -72,7 +84,7 @@ func (opts *ValidateSubCommand) run(input cli.Input) error {
 		return errors.Wrap(err, "error validating specs")
 	}
 
-	err = resourceConflictCheck(opts.Client(), fr, input.Bool(flagkey.SpecAllowConflicts))
+	err = resourceConflictCheck(opts.Client(), fr, input.Bool(flagkey.SpecAllowConflicts), "")
 	if err != nil {
 		return errors.Wrap(err, "name conflict error")
 	}
@@ -90,11 +102,11 @@ func (opts *ValidateSubCommand) run(input cli.Input) error {
 // the same name is already present in the same cluster namespace.
 // If a same name resource exists in the same namespace, a name
 // conflict error will be returned.
-func resourceConflictCheck(c client.Interface, fr *FissionResources, specAllowConflicts bool) error {
+func resourceConflictCheck(c client.Interface, fr *FissionResources, specAllowConflicts bool, namespace string) error {
 	deployUID := fr.DeploymentConfig.UID
 	result := utils.MultiErrorWithFormat()
 
-	fnList, err := getAllFunctions(c)
+	fnList, err := getAllFunctions(c, namespace)
 	if err != nil {
 		return errors.Errorf("Unable to get Functions %v", err.Error())
 	}
@@ -107,7 +119,7 @@ func resourceConflictCheck(c client.Interface, fr *FissionResources, specAllowCo
 		}
 	}
 
-	envList, err := getAllEnvironments(c)
+	envList, err := getAllEnvironments(c, namespace)
 	if err != nil {
 		return errors.Errorf("Unable to get Environments %v", err.Error())
 	}
@@ -120,7 +132,7 @@ func resourceConflictCheck(c client.Interface, fr *FissionResources, specAllowCo
 		}
 	}
 
-	pkgList, err := getAllPackages(c)
+	pkgList, err := getAllPackages(c, namespace)
 	if err != nil {
 		return errors.Errorf("Unable to get Packages %v", err.Error())
 	}
@@ -133,7 +145,7 @@ func resourceConflictCheck(c client.Interface, fr *FissionResources, specAllowCo
 		}
 	}
 
-	httptriggerList, err := getAllHTTPTriggers(c)
+	httptriggerList, err := getAllHTTPTriggers(c, namespace)
 	if err != nil {
 		return errors.Errorf("Unable to get HTTPTrigger %v", err.Error())
 	}
@@ -146,7 +158,7 @@ func resourceConflictCheck(c client.Interface, fr *FissionResources, specAllowCo
 		}
 	}
 
-	mqtriggerList, err := getAllMessageQueueTriggers(c, "")
+	mqtriggerList, err := getAllMessageQueueTriggers(c, "", namespace)
 	if err != nil {
 		return errors.Errorf("Unable to get Message Queue Trigger %v", err.Error())
 	}
@@ -159,7 +171,7 @@ func resourceConflictCheck(c client.Interface, fr *FissionResources, specAllowCo
 		}
 	}
 
-	timetriggerList, err := getAllTimeTriggers(c)
+	timetriggerList, err := getAllTimeTriggers(c, namespace)
 	if err != nil {
 		return errors.Errorf("Unable to get Time Trigger %v", err.Error())
 	}
@@ -172,7 +184,7 @@ func resourceConflictCheck(c client.Interface, fr *FissionResources, specAllowCo
 		}
 	}
 
-	kubewatchtriggerList, err := getAllKubeWatchTriggers(c)
+	kubewatchtriggerList, err := getAllKubeWatchTriggers(c, namespace)
 	if err != nil {
 		return errors.Errorf("Unable to get Kubernetes Watch Trigger %v", err.Error())
 	}