feat: Have default functionglobs in config and use them if no glob is provided

Author: asalkeld

pkg/cmd/deployment/root.go

@@ -52,24 +52,27 @@ var deploymentApplyCmd = &cobra.Command{
 	Use:   "apply [handlerGlob]",
 	Short: "Create or Update a new application deployment",
 	Long:  `Applies a Nitric application deployment.`,
-	Example: `nitric deployment apply
+	Example: `# use a nitric.yaml or configured default handlerGlob (stack in the current directory).
+nitric deployment apply -t aws
+
+# use an explicit handlerGlob (stack in the current directory)
+nitric deployment apply -t aws "functions/*/*.go"
 
-# When using a nitric.yaml
-nitric deployment apply -n prod-aws -s ../project/ -t prod
+# use an explicit handlerGlob and explicit stack directory
+nitric deployment apply -s ../projectX -t aws "functions/*/*.go"
 
-# When using code-as-config, specify the functions.
-nitric deployment apply -n prod-aws -s ../project/ -t prod "functions/*.ts"
-		`,
+# use a custom deployment name
+nitric deployment apply -n prod -t aws`,
 	Run: func(cmd *cobra.Command, args []string) {
 		t, err := target.FromOptions()
 		cobra.CheckErr(err)
 
-		s, err := stack.FromOptions()
+		s, err := stack.FromOptions(args)
 		if err != nil && len(args) > 0 {
 			codeAsConfig := tasklet.Runner{
 				StartMsg: "Gathering configuration from code..",
 				Runner: func(_ output.Progress) error {
-					s, err = stack.FromGlobArgs(args)
+					s, err = stack.FromOptions(args)
 					if err != nil {
 						return err
 					}

pkg/cmd/root.go

@@ -31,9 +31,10 @@ import (
 	"github.com/nitrictech/cli/pkg/cmd/deployment"
 	"github.com/nitrictech/cli/pkg/cmd/provider"
 	"github.com/nitrictech/cli/pkg/cmd/run"
-	"github.com/nitrictech/cli/pkg/cmd/stack"
+	cmdstack "github.com/nitrictech/cli/pkg/cmd/stack"
 	cmdTarget "github.com/nitrictech/cli/pkg/cmd/target"
 	"github.com/nitrictech/cli/pkg/output"
+	"github.com/nitrictech/cli/pkg/stack"
 	"github.com/nitrictech/cli/pkg/target"
 	"github.com/nitrictech/cli/pkg/tasklet"
 	"github.com/nitrictech/cli/pkg/utils"
@@ -96,7 +97,7 @@ func init() {
 
 	rootCmd.AddCommand(deployment.RootCommand())
 	rootCmd.AddCommand(provider.RootCommand())
-	rootCmd.AddCommand(stack.RootCommand())
+	rootCmd.AddCommand(cmdstack.RootCommand())
 	rootCmd.AddCommand(cmdTarget.RootCommand())
 	rootCmd.AddCommand(run.RootCommand())
 	rootCmd.AddCommand(versionCmd)
@@ -146,6 +147,10 @@ func ensureConfigDefaults() {
 		needsWrite = true
 	}
 
+	if stack.EnsureRuntimeDefaults() {
+		needsWrite = true
+	}
+
 	if needsWrite {
 		tasklet.MustRun(tasklet.Runner{
 			StartMsg: "Updating configfile to include defaults",

pkg/cmd/run/root.go

@@ -39,16 +39,20 @@ var runCmd = &cobra.Command{
 	Short: "run a nitric stack",
 	Long: `Run a nitric stack locally for development or testing
 `,
-	Example: `nitric run -s ../projectX "functions/*.ts"`,
+	Example: `# use a nitric.yaml or configured default handlerGlob (stack in the current directory).
+nitric run
+
+# use an explicit handlerGlob (stack in the current directory)
+nitric run "functions/*.ts"
+
+# use an explicit handlerGlob and explicit stack directory
+nitric run -s ../projectX/ "functions/*.ts"`,
 	Run: func(cmd *cobra.Command, args []string) {
 		term := make(chan os.Signal, 1)
 		signal.Notify(term, os.Interrupt, syscall.SIGTERM)
 		signal.Notify(term, os.Interrupt, syscall.SIGINT)
 
-		s, err := stack.FromOptions()
-		if err != nil && len(args) > 0 {
-			s, err = stack.FromGlobArgs(args)
-		}
+		s, err := stack.FromOptions(args)
 		cobra.CheckErr(err)
 
 		ce, err := containerengine.Discover()

pkg/cmd/stack/root.go

@@ -120,16 +120,24 @@ var stackDescribeCmd = &cobra.Command{
 	Use:   "describe [handlerGlob]",
 	Short: "describe stack dependencies",
 	Long:  `Describes stack dependencies`,
+	Example: `# use a nitric.yaml or configured default handlerGlob (stack in the current directory).
+nitric stack describe
+
+# use an explicit handlerGlob (stack in the current directory)
+nitric stack describe "functions/*/*.go"
+
+# use an explicit handlerGlob and explicit stack directory
+nitric stack describe -s ../projectX "functions/*/*.go"`,
 	Run: func(cmd *cobra.Command, args []string) {
-		s, err := stack.FromGlobArgs(args)
+		s, err := stack.FromOptions(args)
 		cobra.CheckErr(err)
 
 		s, err = codeconfig.Populate(s)
 		cobra.CheckErr(err)
 
 		output.Print(s)
 	},
-	Args: cobra.MinimumNArgs(1),
+	Args: cobra.MinimumNArgs(0),
 }
 
 func RootCommand() *cobra.Command {

pkg/stack/options.go

@@ -17,12 +17,16 @@
 package stack
 
 import (
+	"fmt"
 	"os"
 	"path"
 	"path/filepath"
+	"strings"
 
 	"github.com/pkg/errors"
+	"github.com/pterm/pterm"
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 
 	"github.com/nitrictech/cli/pkg/pflagext"
 	"github.com/nitrictech/cli/pkg/runtime"
@@ -43,7 +47,7 @@ func wrapStatError(err error) error {
 	return err
 }
 
-func FromOptions() (*Stack, error) {
+func fromNitricFile() (*Stack, error) {
 	configPath := stackPath
 	ss, err := os.Stat(configPath)
 	if err != nil {
@@ -60,44 +64,62 @@ func FromOptions() (*Stack, error) {
 	return FromFile(configPath)
 }
 
-func FunctionFromHandler(h, stackDir string) Function {
-	rt, _ := runtime.NewRunTimeFromHandler(h)
-	fn := Function{
-		ComputeUnit: ComputeUnit{Name: rt.ContainerName()},
-		Handler:     h,
+func EnsureRuntimeDefaults() bool {
+	defaults := map[string]map[string]interface{}{
+		"ts": {
+			"functionglob": "functions/*.ts",
+		},
+		"go": {
+			"functionglob": "functions/*/*.go",
+		},
 	}
-	fn.SetContextDirectory(stackDir)
-
-	return fn
-}
-
-func FromOptionsMinimal() (*Stack, error) {
-	ss, err := os.Stat(stackPath)
+	written := false
+	runtime, err := utils.ToStringMapStringMapStringE(viper.Get("runtime"))
 	if err != nil {
-		return nil, err
+		fmt.Println("ERROR: runtime configuration in the wrong format")
+		return false
 	}
 
-	sDir := stackPath
-	if !ss.IsDir() {
-		sDir = filepath.Dir(stackPath)
+	for rtName, rt := range defaults {
+		if _, ok := runtime[rtName]; !ok {
+			runtime[rtName] = rt
+			written = true
+		}
+	}
+	if written {
+		viper.Set("runtime", runtime)
 	}
+	return written
+}
 
-	// get the abs dir in case user provides "."
-	absDir, err := filepath.Abs(sDir)
+func defaultGlobsFromConfig() []string {
+	globs := []string{}
+	runtime, err := utils.ToStringMapStringMapStringE(viper.Get("runtime"))
 	if err != nil {
-		return nil, err
+		return globs
+	}
+	for _, rt := range runtime {
+		globs = append(globs, rt["functionglob"].(string))
 	}
-	s := New(path.Base(absDir), sDir)
 
-	return s, nil
+	return globs
 }
 
-func FromGlobArgs(glob []string) (*Stack, error) {
-	s, err := FromOptionsMinimal()
+func FromOptions(glob []string) (*Stack, error) {
+	s, err := fromNitricFile()
+	if err == nil && s != nil {
+		return s, err
+	}
+
+	s, err = FromOptionsMinimal()
 	if err != nil {
 		return nil, err
 	}
 
+	if len(glob) == 0 {
+		glob = defaultGlobsFromConfig()
+	}
+
 	for _, g := range glob {
 		if _, err := os.Stat(g); err != nil {
 			fs, err := utils.GlobInDir(stackPath, g)
@@ -113,13 +135,47 @@ func FromGlobArgs(glob []string) (*Stack, error) {
 			s.Functions[fn.Name] = fn
 		}
 	}
+
 	if len(s.Functions) == 0 {
-		return nil, errors.New("No files where found with glob, try a new pattern")
+		return nil, fmt.Errorf("no functions were found with the glob '%s', try a new pattern", strings.Join(glob, ","))
+	}
+
+	return s, nil
+}
+
+func FromOptionsMinimal() (*Stack, error) {
+	ss, err := os.Stat(stackPath)
+	if err != nil {
+		return nil, err
 	}
 
+	sDir := stackPath
+	if !ss.IsDir() {
+		sDir = filepath.Dir(stackPath)
+	}
+
+	// get the abs dir in case user provides "."
+	absDir, err := filepath.Abs(sDir)
+	if err != nil {
+		return nil, err
+	}
+	s := New(path.Base(absDir), sDir)
+
 	return s, nil
 }
 
+func FunctionFromHandler(h, stackDir string) Function {
+	pterm.Debug.Println("Using function from " + h)
+	rt, _ := runtime.NewRunTimeFromHandler(h)
+	fn := Function{
+		ComputeUnit: ComputeUnit{Name: rt.ContainerName()},
+		Handler:     h,
+	}
+	fn.SetContextDirectory(stackDir)
+
+	return fn
+}
+
 func AddOptions(cmd *cobra.Command) {
 	wd, err := os.Getwd()
 	cobra.CheckErr(err)

pkg/stack/options_test.go

@@ -135,7 +135,7 @@ func TestFromOptions(t *testing.T) {
 	}
 
 	stackPath = tmpDir
-	newS, err := FromOptions()
+	newS, err := FromOptions([]string{})
 	if err != nil {
 		t.Error(err)
 	}
@@ -206,9 +206,9 @@ func TestFromGlobArgs(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-			got, err := FromGlobArgs(tt.glob)
+			got, err := FromOptions(tt.glob)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("FromGlobArgs() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("FromOptions() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if !reflect.DeepEqual(want, got) {

pkg/target/options.go

@@ -18,15 +18,14 @@ package target
 
 import (
 	"errors"
-	"fmt"
 	"strings"
 
 	"github.com/mitchellh/mapstructure"
-	"github.com/spf13/cast"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
 	"github.com/nitrictech/cli/pkg/pflagext"
+	"github.com/nitrictech/cli/pkg/utils"
 )
 
 const (
@@ -46,30 +45,10 @@ var (
 	Providers   = []string{Aws, Azure, Gcp, Digitalocean}
 )
 
-func ToStringMapStringMapStringE(i interface{}) (map[string]map[string]interface{}, error) {
-	switch v := i.(type) {
-	case map[string]map[string]interface{}:
-		return v, nil
-	case map[string]interface{}:
-		var err error
-		m := make(map[string]map[string]interface{})
-
-		for k, val := range v {
-			m[k], err = cast.ToStringMapE(val)
-			if err != nil {
-				return nil, err
-			}
-		}
-		return m, nil
-	default:
-		return nil, fmt.Errorf("unable to cast %#v of type %T to map[string]map[string]interface{}", i, i)
-	}
-}
-
 func EnsureDefaultConfig() bool {
 	written := false
 
-	targets, err := ToStringMapStringMapStringE(viper.Get("targets"))
+	targets, err := utils.ToStringMapStringMapStringE(viper.Get("targets"))
 	if err != nil {
 		targets = map[string]map[string]interface{}{}
 	}
@@ -98,7 +77,7 @@ func EnsureDefaultConfig() bool {
 }
 
 func AllFromConfig() (map[string]Target, error) {
-	tsMap, err := ToStringMapStringMapStringE(viper.Get("targets"))
+	tsMap, err := utils.ToStringMapStringMapStringE(viper.Get("targets"))
 	if err != nil {
 		return nil, err
 	}