Merge pull request #315 from fujiwara/kong

use Kong instead of kingpin.

Author: fujiwara

archive.go

@@ -17,13 +17,13 @@ import (
 
 // Archive archives zip
 func (app *App) Archive(ctx context.Context, opt DeployOption) error {
-	excludes, err := expandExcludeFile(*opt.ExcludeFile)
+	excludes, err := expandExcludeFile(opt.ExcludeFile)
 	if err != nil {
 		return fmt.Errorf("failed to parse exclude file: %w", err)
 	}
-	opt.Excludes = append(opt.Excludes, excludes...)
+	opt.excludes = append(opt.excludes, excludes...)
 
-	zipfile, _, err := createZipArchive(*opt.Src, opt.Excludes)
+	zipfile, _, err := createZipArchive(opt.Src, opt.excludes)
 	if err != nil {
 		return err
 	}

cli.go

@@ -0,0 +1,132 @@
+package lambroll
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+
+	"github.com/alecthomas/kong"
+	"github.com/fatih/color"
+	"github.com/fujiwara/logutils"
+)
+
+type Option struct {
+	Function string `help:"Function file path"`
+	LogLevel string `help:"log level (trace, debug, info, warn, error)" default:"info" enum:"trace,debug,info,warn,error"`
+	Color    bool   `help:"enable colored output" default:"false"`
+
+	Region          *string           `help:"AWS region" environment:"AWS_REGION"`
+	Profile         *string           `help:"AWS credential profile name" environment:"AWS_PROFILE"`
+	TFState         *string           `name:"tfstate" help:"URL to terraform.tfstate"`
+	PrefixedTFState map[string]string `name:"prefixed-tfstate" help:"key value pair of the prefix for template function name and URL to terraform.tfstate"`
+	Endpoint        *string           `help:"AWS API Lambda Endpoint"`
+	Envfile         []string          `help:"environment files"`
+	ExtStr          map[string]string `help:"external string values for Jsonnet"`
+	ExtCode         map[string]string `help:"external code values for Jsonnet"`
+}
+
+type CLIOptions struct {
+	Option
+
+	Deploy   *DeployOption   `cmd:"deploy" help:"deploy or create function"`
+	Init     *InitOption     `cmd:"init" help:"init function.json"`
+	List     *ListOption     `cmd:"list" help:"list functions"`
+	Rollback *RollbackOption `cmd:"rollback" help:"rollback function"`
+	Invoke   *InvokeOption   `cmd:"invoke" help:"invoke function"`
+	Archive  *DeployOption   `cmd:"archive" help:"archive function"`
+	Logs     *LogsOption     `cmd:"logs" help:"show logs of function"`
+	Diff     *DiffOption     `cmd:"diff" help:"show diff of function"`
+	Versions *VersionsOption `cmd:"versions" help:"show versions of function"`
+
+	Version struct{} `cmd:"version" help:"show version"`
+}
+
+type CLIParseFunc func([]string) (string, *CLIOptions, func(), error)
+
+func ParseCLI(args []string) (string, *CLIOptions, func(), error) {
+	// compatible with v1
+	if len(args) == 0 || len(args) > 0 && args[0] == "help" {
+		args = []string{"--help"}
+	}
+
+	var opts CLIOptions
+	parser, err := kong.New(&opts, kong.Vars{"version": Version})
+	if err != nil {
+		return "", nil, nil, fmt.Errorf("failed to new kong: %w", err)
+	}
+	c, err := parser.Parse(args)
+	if err != nil {
+		return "", nil, nil, fmt.Errorf("failed to parse args: %w", err)
+	}
+	sub := strings.Fields(c.Command())[0]
+	return sub, &opts, func() { c.PrintUsage(true) }, nil
+}
+
+func CLI(ctx context.Context, parse CLIParseFunc) (int, error) {
+	sub, opts, usage, err := parse(os.Args[1:])
+	if err != nil {
+		return 1, err
+	}
+
+	color.NoColor = opts.Color
+	filter := &logutils.LevelFilter{
+		Levels: []logutils.LogLevel{"debug", "info", "warn", "error"},
+		ModifierFuncs: []logutils.ModifierFunc{
+			logutils.Color(color.FgHiBlack), // debug
+			nil,                             // info
+			logutils.Color(color.FgYellow),  // warn
+			logutils.Color(color.FgRed),     // error
+		},
+		MinLevel: logutils.LogLevel(opts.LogLevel),
+		Writer:   os.Stderr,
+	}
+	log.SetOutput(filter)
+
+	if err := dispatchCLI(ctx, sub, usage, opts); err != nil {
+		return 1, err
+	}
+	return 0, nil
+}
+
+func dispatchCLI(ctx context.Context, sub string, usage func(), opts *CLIOptions) error {
+	switch sub {
+	case "version", "":
+		fmt.Println("lambroll", Version)
+		return nil
+	}
+
+	app, err := New(ctx, &opts.Option)
+	if err != nil {
+		return err
+	}
+	if opts.Function != "" {
+		log.Printf("[info] lambroll %s with %s", Version, opts.Function)
+	} else {
+		log.Printf("[info] lambroll %s", Version)
+	}
+	switch sub {
+	case "init":
+		return app.Init(ctx, *opts.Init)
+	case "list":
+		return app.List(ctx, *opts.List)
+	case "deploy":
+		return app.Deploy(ctx, *opts.Deploy)
+	case "invoke":
+		return app.Invoke(ctx, *opts.Invoke)
+	case "logs":
+		return app.Logs(ctx, *opts.Logs)
+	case "versions":
+		return app.Versions(ctx, *opts.Versions)
+	case "archive":
+		return app.Archive(ctx, *opts.Archive)
+	case "rollback":
+		return app.Rollback(ctx, *opts.Rollback)
+	case "diff":
+		return app.Diff(ctx, *opts.Diff)
+	default:
+		usage()
+	}
+	return nil
+}

cmd/lambroll/main.go

@@ -2,24 +2,38 @@ package main
 
 import (
 	"context"
-	"fmt"
+	"errors"
 	"log"
 	"os"
+	"os/signal"
 
-	"github.com/alecthomas/kingpin"
-	"github.com/fatih/color"
 	"github.com/fujiwara/lambroll"
-	"github.com/fujiwara/logutils"
-	"github.com/mattn/go-isatty"
+	"golang.org/x/sys/unix"
 )
 
 // Version number
 var Version = "current"
 
 func main() {
-	os.Exit(_main())
+	os.Exit(_mainv2())
 }
 
+func _mainv2() int {
+	lambroll.Version = Version
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, unix.SIGTERM)
+	defer stop()
+
+	exitCode, err := lambroll.CLI(ctx, lambroll.ParseCLI)
+	if err != nil {
+		if errors.Is(err, context.Canceled) {
+			log.Println("[warn] Interrupted")
+		} else {
+			log.Printf("[error] FAILED. %s", err)
+		}
+	}
+	return exitCode
+}
+/*
 func _main() int {
 	kingpin.Command("version", "show version")
 	logLevel := kingpin.Flag("log-level", "log level (trace, debug, info, warn, error)").Default("info").Enum("trace", "debug", "info", "warn", "error")
@@ -173,3 +187,4 @@ func _main() int {
 	log.Println("[info] completed")
 	return 0
 }
+*/

create.go

@@ -47,14 +47,14 @@ func (app *App) prepareFunctionCodeForDeploy(ctx context.Context, opt DeployOpti
 		return nil
 	}
 
-	if opt.SkipArchive != nil && *opt.SkipArchive {
+	if opt.SkipArchive {
 		if fn.Code == nil || fn.Code.S3Bucket == nil || fn.Code.S3Key == nil {
 			return fmt.Errorf("--skip-archive requires Code.S3Bucket and Code.S3key elements in function definition")
 		}
 		return nil
 	}
 
-	zipfile, info, err := prepareZipfile(*opt.Src, opt.Excludes)
+	zipfile, info, err := prepareZipfile(opt.Src, opt.excludes)
 	if err != nil {
 		return err
 	}
@@ -99,8 +99,8 @@ func (app *App) create(ctx context.Context, opt DeployOption, fn *Function) erro
 	log.Println("[info] creating function", opt.label())
 
 	version := "(created)"
-	if !*opt.DryRun {
-		fn.Publish = *opt.Publish
+	if !opt.DryRun {
+		fn.Publish = opt.Publish
 		res, err := app.createFunction(ctx, fn)
 		if err != nil {
 			return fmt.Errorf("failed to create function: %w", err)
@@ -117,16 +117,16 @@ func (app *App) create(ctx context.Context, opt DeployOption, fn *Function) erro
 		return err
 	}
 
-	if !*opt.Publish {
+	if !opt.Publish {
 		return nil
 	}
 
-	log.Printf("[info] creating alias set %s to version %s %s", *opt.AliasName, version, opt.label())
-	if !*opt.DryRun {
+	log.Printf("[info] creating alias set %s to version %s %s", opt.AliasName, version, opt.label())
+	if !opt.DryRun {
 		_, err := app.lambda.CreateAlias(ctx, &lambda.CreateAliasInput{
 			FunctionName:    fn.FunctionName,
 			FunctionVersion: aws.String(version),
-			Name:            aws.String(*opt.AliasName),
+			Name:            aws.String(opt.AliasName),
 		})
 		if err != nil {
 			return fmt.Errorf("failed to create alias: %w", err)

delete.go

@@ -10,8 +10,7 @@ import (
 
 // DeleteOption represents options for Delete()
 type DeleteOption struct {
-	FunctionFilePath *string
-	DryRun           *bool
+	DryRun *bool
 }
 
 func (opt DeleteOption) label() string {
@@ -23,7 +22,7 @@ func (opt DeleteOption) label() string {
 
 // Delete deletes function
 func (app *App) Delete(ctx context.Context, opt DeleteOption) error {
-	fn, err := app.loadFunction(*opt.FunctionFilePath)
+	fn, err := app.loadFunction(app.functionFilePath)
 	if err != nil {
 		return fmt.Errorf("failed to load function: %w", err)
 	}

deploy.go

@@ -16,20 +16,20 @@ import (
 
 // DeployOption represens an option for Deploy()
 type DeployOption struct {
-	FunctionFilePath *string
-	Src              *string
-	Excludes         []string
-	ExcludeFile      *string
-	Publish          *bool
-	AliasName        *string
-	AliasToLatest    *bool
-	DryRun           *bool
-	SkipArchive      *bool
-	KeepVersions     *int
+	Src           string `help:"function zip archive or src dir" default:"."`
+	ExcludeFile   string `help:"exclude file" default:".lambdaignore"`
+	Publish       bool   `help:"publish function" default:"true"`
+	AliasName     string `help:"alias name for publish" default:"current"`
+	AliasToLatest bool   `help:"set alias to unpublished $LATEST version" default:"false"`
+	DryRun        bool   `help:"dry run" default:"false"`
+	SkipArchive   bool   `help:"skip to create zip archive. requires Code.S3Bucket and Code.S3Key in function definition" default:"false"`
+	KeepVersions  int    `help:"Number of latest versions to keep. Older versions will be deleted. (Optional value: default 0)." default:"0"`
+
+	excludes []string
 }
 
 func (opt DeployOption) label() string {
-	if *opt.DryRun {
+	if opt.DryRun {
 		return "**DRY RUN**"
 	}
 	return ""
@@ -69,14 +69,14 @@ func (opt *DeployOption) String() string {
 
 // Deploy deployes a new lambda function code
 func (app *App) Deploy(ctx context.Context, opt DeployOption) error {
-	excludes, err := expandExcludeFile(*opt.ExcludeFile)
+	excludes, err := expandExcludeFile(opt.ExcludeFile)
 	if err != nil {
 		return fmt.Errorf("failed to parse exclude-file: %w", err)
 	}
-	opt.Excludes = append(opt.Excludes, excludes...)
+	opt.excludes = append(opt.excludes, excludes...)
 	log.Printf("[debug] %s", opt.String())
 
-	fn, err := app.loadFunction(*opt.FunctionFilePath)
+	fn, err := app.loadFunction(app.functionFilePath)
 	if err != nil {
 		return fmt.Errorf("failed to load function: %w", err)
 	}
@@ -129,7 +129,7 @@ func (app *App) Deploy(ctx context.Context, opt DeployOption) error {
 	log.Printf("[debug]\n%s", ToJSONString(confIn))
 
 	var newerVersion string
-	if !*opt.DryRun {
+	if !opt.DryRun {
 		proc := func(ctx context.Context) error {
 			return app.updateFunctionConfiguration(ctx, confIn)
 		}
@@ -150,10 +150,10 @@ func (app *App) Deploy(ctx context.Context, opt DeployOption) error {
 		S3ObjectVersion: fn.Code.S3ObjectVersion,
 		ImageUri:        fn.Code.ImageUri,
 	}
-	if *opt.DryRun {
+	if opt.DryRun {
 		codeIn.DryRun = true
 	} else {
-		codeIn.Publish = *opt.Publish
+		codeIn.Publish = opt.Publish
 	}
 
 	var res *lambda.UpdateFunctionCodeOutput
@@ -173,17 +173,17 @@ func (app *App) Deploy(ctx context.Context, opt DeployOption) error {
 		newerVersion = versionLatest
 		log.Printf("[info] deployed version %s %s", newerVersion, opt.label())
 	}
-	if *opt.DryRun {
+	if opt.DryRun {
 		return nil
 	}
-	if *opt.Publish || *opt.AliasToLatest {
-		err := app.updateAliases(ctx, *fn.FunctionName, versionAlias{newerVersion, *opt.AliasName})
+	if opt.Publish || opt.AliasToLatest {
+		err := app.updateAliases(ctx, *fn.FunctionName, versionAlias{newerVersion, opt.AliasName})
 		if err != nil {
 			return err
 		}
 	}
-	if *opt.KeepVersions > 0 { // Ignore zero-value.
-		return app.deleteVersions(ctx, *fn.FunctionName, *opt.KeepVersions)
+	if opt.KeepVersions > 0 { // Ignore zero-value.
+		return app.deleteVersions(ctx, *fn.FunctionName, opt.KeepVersions)
 	}
 	return nil
 }

deploy_test.go

@@ -13,20 +13,18 @@ var expectExcludes = []string{
 
 func TestDeployOptionExpand(t *testing.T) {
 	file := "test/src/.lambdaignore"
-	opt := lambroll.DeployOption{
-		ExcludeFile: &file,
-	}
-	excludes, err := lambroll.ExpandExcludeFile(*opt.ExcludeFile)
+	excludes := []string{}
+	ex, err := lambroll.ExpandExcludeFile(file)
 	if err != nil {
 		t.Error("failed to expand", err)
 	}
-	opt.Excludes = append(opt.Excludes, excludes...)
-	if len(opt.Excludes) != len(expectExcludes) {
-		t.Errorf("unexpeted expanded excludes %#v", opt.Excludes)
+	excludes = append(excludes, ex...)
+	if len(excludes) != len(expectExcludes) {
+		t.Errorf("unexpeted expanded excludes %#v", excludes)
 	}
 	for i, line := range expectExcludes {
-		if line != opt.Excludes[i] {
-			t.Errorf("unexpected expanded excludes[%d] expected:%s, got:%s", i, line, opt.Excludes[i])
+		if line != excludes[i] {
+			t.Errorf("unexpected expanded excludes[%d] expected:%s, got:%s", i, line, excludes[i])
 		}
 	}
 }