feat: pass stack config through to pulumi providers

Author: asalkeld

hack/allmods/main.go

@@ -21,7 +21,7 @@ import (
 	"os"
 	"strings"
 
-	"github.com/golangci/golangci-lint/pkg/sliceutil"
+	"golang.org/x/exp/slices"
 	"golang.org/x/mod/modfile"
 )
 
@@ -41,7 +41,7 @@ func main() {
 	mods := []string{}
 
 	for _, r := range mf.Require {
-		if sliceutil.Contains(ignoreList, r.Mod.Path) {
+		if slices.Contains(ignoreList, r.Mod.Path) {
 			continue
 		}
 

pkg/cmd/stack/root.go

@@ -22,7 +22,6 @@ import (
 	"log"
 	"os"
 	"path"
-	"path/filepath"
 	"runtime"
 
 	"github.com/AlecAivazis/survey/v2"
@@ -89,21 +88,18 @@ var newStackCmd = &cobra.Command{
 		pName := ""
 		err = survey.AskOne(&survey.Select{
 			Message: "Which Cloud do you wish to deploy to?",
-			Default: stack.Aws,
-			Options: stack.Providers,
+			Default: types.Aws,
+			Options: types.Providers,
 		}, &pName)
 		cobra.CheckErr(err)
 
 		pc, err := project.ConfigFromProjectPath("")
 		cobra.CheckErr(err)
 
-		prov, err := provider.NewProvider(project.New(pc), &stack.Config{Name: name, Provider: pName}, map[string]string{}, &types.ProviderOpts{})
+		prov, err := provider.NewProvider(project.New(pc), name, pName, map[string]string{}, &types.ProviderOpts{})
 		cobra.CheckErr(err)
 
-		sc, err := prov.Ask()
-		cobra.CheckErr(err)
-
-		err = sc.ToFile(filepath.Join(pc.Dir, fmt.Sprintf("nitric-%s.yaml", sc.Name)))
+		err = prov.AskAndSave()
 		cobra.CheckErr(err)
 	},
 	Args:        cobra.MaximumNArgs(2),
@@ -175,7 +171,7 @@ var stackUpdateCmd = &cobra.Command{
 		}
 		tasklet.MustRun(codeAsConfig, tasklet.Opts{})
 
-		p, err := provider.NewProvider(proj, s, envMap, &types.ProviderOpts{Force: force})
+		p, err := provider.NewProvider(proj, s.Name, s.Provider, envMap, &types.ProviderOpts{Force: force})
 		cobra.CheckErr(err)
 
 		d := &types.Deployment{}
@@ -236,7 +232,7 @@ nitric stack down -e aws -y`,
 		proj, err := project.FromConfig(config)
 		cobra.CheckErr(err)
 
-		p, err := provider.NewProvider(proj, s, map[string]string{}, &types.ProviderOpts{Force: true})
+		p, err := provider.NewProvider(proj, s.Name, s.Provider, map[string]string{}, &types.ProviderOpts{Force: true})
 		cobra.CheckErr(err)
 
 		deploy := tasklet.Runner{
@@ -275,7 +271,7 @@ nitric stack list -s aws
 		proj, err := project.FromConfig(config)
 		cobra.CheckErr(err)
 
-		p, err := provider.NewProvider(proj, s, map[string]string{}, &types.ProviderOpts{})
+		p, err := provider.NewProvider(proj, s.Name, s.Provider, map[string]string{}, &types.ProviderOpts{})
 		cobra.CheckErr(err)
 
 		deps, err := p.List()

pkg/codeconfig/codeconfig.go

@@ -606,7 +606,7 @@ func (c *codeConfig) ToProject() (*project.Project, error) {
 
 		fun, ok := s.Functions[f.name]
 		if !ok {
-			fun, err = project.FunctionFromHandler(handler, s.Dir)
+			fun, err = project.FunctionFromHandler(handler)
 			if err != nil {
 				errs.Push(fmt.Errorf("can not create function from %s %w", handler, err))
 				continue

pkg/output/format_test.go

@@ -35,12 +35,11 @@ func Test_printStruct(t *testing.T) {
 	}{
 		{
 			name:   "json tags",
-			object: stack.Config{Name: "prod", Provider: "azure", Region: "somewhere"},
-			expect: `+----------+-----------+
-| NAME     | prod      |
-| PROVIDER | azure     |
-| REGION   | somewhere |
-+----------+-----------+
+			object: stack.Config{Name: "prod", Provider: "azure"},
+			expect: `+----------+-------+
+| NAME     | prod  |
+| PROVIDER | azure |
++----------+-------+
 `,
 		},
 	}
@@ -64,15 +63,15 @@ func Test_printList(t *testing.T) {
 		{
 			name: "json tags",
 			object: []stack.Config{
-				{Name: "a", Provider: "azure", Region: "somewhere"},
-				{Name: "b", Provider: "aws", Region: "xyz"},
+				{Name: "a", Provider: "azure"},
+				{Name: "b", Provider: "aws"},
 			},
-			expect: `+------+----------+-----------+
-| NAME | PROVIDER | REGION    |
-+------+----------+-----------+
-| b    | aws      | xyz       |
-| a    | azure    | somewhere |
-+------+----------+-----------+
+			expect: `+------+----------+
+| NAME | PROVIDER |
++------+----------+
+| b    | aws      |
+| a    | azure    |
++------+----------+
 `,
 		},
 	}
@@ -99,15 +98,15 @@ func Test_printMap(t *testing.T) {
 		{
 			name: "json tags",
 			object: map[string]stack.Config{
-				"t1": {Provider: "azure", Region: "somewhere"},
-				"t3": {Provider: "aws", Name: "foo"},
+				"t1": {Provider: "azure"},
+				"t3": {Name: "foo", Provider: "aws"},
 			},
-			wantOut: `+-----+------+----------+-----------+
-| KEY | NAME | PROVIDER | REGION    |
-+-----+------+----------+-----------+
-| t1  |      | azure    | somewhere |
-| t3  | foo  | aws      |           |
-+-----+------+----------+-----------+
+			wantOut: `+-----+------+----------+
+| KEY | NAME | PROVIDER |
++-----+------+----------+
+| t1  |      | azure    |
+| t3  | foo  | aws      |
++-----+------+----------+
 `,
 		},
 	}

pkg/project/options.go

@@ -30,44 +30,44 @@ import (
 
 var stackPath string
 
-func FromConfig(p *Config) (*Project, error) {
-	s := New(p)
+func FromConfig(c *Config) (*Project, error) {
+	p := New(c)
 
-	for _, g := range p.Handlers {
-		maybeFile := filepath.Join(s.Dir, g)
+	for _, h := range c.Handlers {
+		maybeFile := filepath.Join(p.Dir, h)
 
 		if _, err := os.Stat(maybeFile); err != nil {
-			fs, err := utils.GlobInDir(stackPath, g)
+			fs, err := utils.GlobInDir(stackPath, h)
 			if err != nil {
 				return nil, err
 			}
 
 			for _, f := range fs {
-				fn, err := FunctionFromHandler(f, s.Dir)
+				fn, err := FunctionFromHandler(f)
 				if err != nil {
 					return nil, err
 				}
 
-				s.Functions[fn.Name] = fn
+				p.Functions[fn.Name] = fn
 			}
 		} else {
-			fn, err := FunctionFromHandler(g, s.Dir)
+			fn, err := FunctionFromHandler(h)
 			if err != nil {
 				return nil, err
 			}
 
-			s.Functions[fn.Name] = fn
+			p.Functions[fn.Name] = fn
 		}
 	}
 
-	if len(s.Functions) == 0 {
-		return nil, fmt.Errorf("no functions were found with the glob '%s', try a new pattern", strings.Join(p.Handlers, ","))
+	if len(p.Functions) == 0 {
+		return nil, fmt.Errorf("no functions were found with the glob '%s', try a new pattern", strings.Join(c.Handlers, ","))
 	}
 
-	return s, nil
+	return p, nil
 }
 
-func FunctionFromHandler(h, stackDir string) (Function, error) {
+func FunctionFromHandler(h string) (Function, error) {
 	pterm.Debug.Println("Using function from " + h)
 
 	rt, err := runtime.NewRunTimeFromHandler(h)
@@ -76,7 +76,9 @@ func FunctionFromHandler(h, stackDir string) (Function, error) {
 	}
 
 	return Function{
-		ComputeUnit: ComputeUnit{Name: rt.ContainerName()},
-		Handler:     h,
+		ComputeUnit: ComputeUnit{
+			Name: rt.ContainerName(),
+		},
+		Handler: h,
 	}, nil
 }

pkg/project/options_test.go

@@ -43,8 +43,10 @@ func TestFromConfig(t *testing.T) {
 				Name: "project",
 				Functions: map[string]Function{
 					"project": {
-						Handler:     "types.go",
-						ComputeUnit: ComputeUnit{Name: "project"},
+						Handler: "types.go",
+						ComputeUnit: ComputeUnit{
+							Name: "project",
+						},
 					},
 				},
 			},
@@ -61,8 +63,10 @@ func TestFromConfig(t *testing.T) {
 				Name: "pkg",
 				Functions: map[string]Function{
 					"stack": {
-						Handler:     "stack/options.go",
-						ComputeUnit: ComputeUnit{Name: "stack"},
+						Handler: "stack/options.go",
+						ComputeUnit: ComputeUnit{
+							Name: "stack",
+						},
 					},
 				},
 			},

pkg/project/types.go

@@ -39,14 +39,17 @@ type ComputeUnit struct {
 	// Triggers used to invoke this compute unit, e.g. Topic Subscriptions
 	Triggers Triggers `yaml:"triggers,omitempty"`
 
-	// The memory of the compute instance in MB
+	// The memory of the compute instance in MB: default 128
 	Memory int `yaml:"memory,omitempty"`
 
-	// The minimum number of instances to keep alive
+	// The minimum number of instances to keep alive: default 0
 	MinScale int `yaml:"minScale,omitempty"`
 
-	// The maximum number of instances to scale to
+	// The maximum number of instances to scale to: default 10
 	MaxScale int `yaml:"maxScale,omitempty"`
+
+	// The max running time of the function: default 15
+	Timeout int `yaml:"timeout,omitempty"`
 }
 
 type Function struct {

pkg/provider/generator.go

@@ -22,15 +22,14 @@ import (
 	"github.com/nitrictech/cli/pkg/project"
 	"github.com/nitrictech/cli/pkg/provider/pulumi"
 	"github.com/nitrictech/cli/pkg/provider/types"
-	"github.com/nitrictech/cli/pkg/stack"
 	"github.com/nitrictech/cli/pkg/utils"
 )
 
-func NewProvider(p *project.Project, s *stack.Config, envMap map[string]string, opts *types.ProviderOpts) (types.Provider, error) {
-	switch s.Provider {
-	case stack.Aws, stack.Azure, stack.Digitalocean, stack.Gcp:
-		return pulumi.New(p, s, envMap, opts)
+func NewProvider(p *project.Project, name, provider string, envMap map[string]string, opts *types.ProviderOpts) (types.Provider, error) {
+	switch provider {
+	case types.Aws, types.Azure, types.Digitalocean, types.Gcp:
+		return pulumi.New(p, name, provider, envMap, opts)
 	default:
-		return nil, utils.NewNotSupportedErr(fmt.Sprintf("provider %s is not supported", s.Provider))
+		return nil, utils.NewNotSupportedErr(fmt.Sprintf("provider %s is not supported", provider))
 	}
 }