Merge pull request #91 from mutablelogic/v5

V5

Author: djthorpe

cmd.go

@@ -13,6 +13,9 @@ import (
 
 // Cmd represents the command line interface context
 type Cmd interface {
+	// Run the command
+	Run() error
+
 	// Return the context
 	Context() context.Context
 
@@ -31,11 +34,6 @@ type Cmd interface {
 
 type DebugLevel uint
 
-type CmdOffsetLimit struct {
-	Offset uint64  `name:"offset" help:"List item offset"`
-	Limit  *uint64 `name:"limit" help:"List item limit"`
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // GLOBALS
 

cmd/server/main.go

@@ -1,28 +1,21 @@
 package main
 
 import (
+	"fmt"
 	"os"
-	"os/user"
-	"path/filepath"
 
 	// Packages
-	kong "github.com/alecthomas/kong"
-	server "github.com/mutablelogic/go-server"
 	auth "github.com/mutablelogic/go-server/pkg/auth/cmd"
-	auth_schema "github.com/mutablelogic/go-server/pkg/auth/schema"
 	certmanager "github.com/mutablelogic/go-server/pkg/cert/cmd"
-	cert_schema "github.com/mutablelogic/go-server/pkg/cert/schema"
+	cmd "github.com/mutablelogic/go-server/pkg/cmd"
 	pgmanager "github.com/mutablelogic/go-server/pkg/pgmanager/cmd"
-	pgmanager_schema "github.com/mutablelogic/go-server/pkg/pgmanager/schema"
 	pgqueue "github.com/mutablelogic/go-server/pkg/pgqueue/cmd"
-	pgqueue_schema "github.com/mutablelogic/go-server/pkg/pgqueue/schema"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
 // TYPES
 
 type CLI struct {
-	Globals
 	ServiceCommands
 	pgmanager.DatabaseCommands
 	pgmanager.SchemaCommands
@@ -47,57 +40,15 @@ type CLI struct {
 func main() {
 	// Parse command-line flags
 	var cli CLI
-	kong := kong.Parse(&cli,
-		kong.Name(execName()),
-		kong.Description("command-line tool"),
-		kong.UsageOnError(),
-		kong.ConfigureHelp(kong.HelpOptions{Compact: true}),
-		kong.Vars{
-			"HOST":         hostName(),
-			"USER":         userName(),
-			"CERT_PREFIX":  cert_schema.APIPrefix,
-			"PG_PREFIX":    pgmanager_schema.APIPrefix,
-			"AUTH_PREFIX":  auth_schema.APIPrefix,
-			"QUEUE_PREFIX": pgqueue_schema.APIPrefix,
-		},
-	)
 
-	// Create the app
-	app, err := NewApp(cli.Globals, kong.Model.Vars())
+	app, err := cmd.New(&cli, "go-server command-line tool")
 	if err != nil {
-		kong.FatalIfErrorf(err)
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(-1)
 	}
-	defer app.Close()
 
-	// Run
-	kong.BindTo(app, (*server.Cmd)(nil))
-	kong.FatalIfErrorf(kong.Run())
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// PRIVATE METHODS
-
-func hostName() string {
-	name, err := os.Hostname()
-	if err != nil {
-		panic(err)
-	}
-	return name
-}
-
-func userName() string {
-	user, err := user.Current()
-	if err != nil {
-		panic(err)
-	}
-	return user.Username
-}
-
-func execName() string {
-	// The name of the executable
-	name, err := os.Executable()
-	if err != nil {
-		panic(err)
+	if err := app.Run(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(-2)
 	}
-	return filepath.Base(name)
 }

cmd/server/service.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"errors"
+	"fmt"
 	"net/http"
 	"os"
 
@@ -17,6 +18,7 @@ import (
 	provider "github.com/mutablelogic/go-server/pkg/provider"
 	ref "github.com/mutablelogic/go-server/pkg/ref"
 	types "github.com/mutablelogic/go-server/pkg/types"
+	version "github.com/mutablelogic/go-server/pkg/version"
 
 	// Plugins
 	auth "github.com/mutablelogic/go-server/pkg/auth/config"
@@ -201,6 +203,8 @@ func (cmd *ServiceRunCommand) Run(app server.Cmd) error {
 		return err
 	}
 
+	fmt.Println("go-server", version.Version())
+
 	// Run the provider
 	return provider.Run(app.Context())
 }

pkg/auth/manager_test.go

@@ -301,7 +301,7 @@ func Test_Auth_002(t *testing.T) {
 
 	// Create a new user
 	user, err := manager.CreateUser(context.TODO(), schema.UserMeta{
-		Name:  types.StringPtr("test"),
+		Name:  types.StringPtr("test20"),
 		Desc:  types.StringPtr("test user"),
 		Scope: []string{},
 		Meta:  map[string]any{},
@@ -312,7 +312,7 @@ func Test_Auth_002(t *testing.T) {
 
 	// Create a new user and archive
 	archived, err := manager.CreateUser(context.TODO(), schema.UserMeta{
-		Name:  types.StringPtr("test2"),
+		Name:  types.StringPtr("test21"),
 		Desc:  types.StringPtr("test user"),
 		Scope: []string{},
 		Meta:  map[string]any{},
@@ -372,7 +372,7 @@ func Test_Auth_002(t *testing.T) {
 	t.Run("GetToken3", func(t *testing.T) {
 		// Create a new user
 		user, err := manager.CreateUser(context.TODO(), schema.UserMeta{
-			Name:  types.StringPtr("test3"),
+			Name:  types.StringPtr("test22"),
 			Desc:  types.StringPtr("test user"),
 			Scope: []string{},
 			Meta:  map[string]any{},
@@ -498,7 +498,7 @@ func Test_Auth_003(t *testing.T) {
 
 	// Create a new user
 	user, err := manager.CreateUser(context.TODO(), schema.UserMeta{
-		Name:  types.StringPtr("test"),
+		Name:  types.StringPtr("test30"),
 		Desc:  types.StringPtr("test user"),
 		Scope: []string{},
 		Meta:  map[string]any{},

pkg/cert/cmd/name.go

@@ -22,7 +22,7 @@ type NameCommands struct {
 }
 
 type NameListCommand struct {
-	server.CmdOffsetLimit
+	schema.NameListRequest
 }
 
 type NameMeta struct {

cmd/server/app.go renamed to pkg/cmd/app.go

@@ -1,11 +1,12 @@
-package main
+package cmd
 
 import (
 	"context"
 	"fmt"
 	"net/url"
 	"os"
 	"os/signal"
+	"os/user"
 	"path/filepath"
 	"syscall"
 
@@ -20,46 +21,60 @@ import (
 ///////////////////////////////////////////////////////////////////////////////
 // TYPES
 
-type Globals struct {
+type app struct {
 	Endpoint string `env:"ENDPOINT" default:"http://localhost/" help:"Service endpoint"`
 	Debug    bool   `help:"Enable debug output"`
 	Trace    bool   `help:"Enable trace output"`
 
-	vars   kong.Vars `kong:"-"` // Variables for kong
+	kong   *kong.Context `kong:"-"` // Kong parser
+	vars   kong.Vars     `kong:"-"` // Variables for kong
 	ctx    context.Context
 	cancel context.CancelFunc
 }
 
-var _ server.Cmd = (*Globals)(nil)
+var _ server.Cmd = (*app)(nil)
 
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
-func NewApp(app Globals, vars kong.Vars) (*Globals, error) {
-	// Set the vars
-	app.vars = vars
+func New(commands any, description string) (server.Cmd, error) {
+	app := new(app)
+
+	app.kong = kong.Parse(commands,
+		kong.Name(execName()),
+		kong.Description(description),
+		kong.UsageOnError(),
+		kong.ConfigureHelp(kong.HelpOptions{Compact: true}),
+		kong.Embed(app),
+		kong.Vars{
+			"HOST": hostName(),
+			"USER": userName(),
+		},
+	)
 
 	// Create the context
 	// This context is cancelled when the process receives a SIGINT or SIGTERM
 	app.ctx, app.cancel = signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
 
 	// Return the app
-	return &app, nil
+	return app, nil
 }
 
-func (app *Globals) Close() error {
+func (app *app) Run() error {
+	app.kong.BindTo(app, (*server.Cmd)(nil))
+	err := app.kong.Run()
 	app.cancel()
-	return nil
+	return err
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 
-func (app *Globals) Context() context.Context {
+func (app *app) Context() context.Context {
 	return app.ctx
 }
 
-func (app *Globals) GetDebug() server.DebugLevel {
+func (app *app) GetDebug() server.DebugLevel {
 	if app.Debug {
 		return server.Debug
 	}
@@ -69,7 +84,7 @@ func (app *Globals) GetDebug() server.DebugLevel {
 	return server.None
 }
 
-func (app *Globals) GetEndpoint(paths ...string) *url.URL {
+func (app *app) GetEndpoint(paths ...string) *url.URL {
 	url, err := url.Parse(app.Endpoint)
 	if err != nil {
 		return nil
@@ -82,7 +97,7 @@ func (app *Globals) GetEndpoint(paths ...string) *url.URL {
 	return url
 }
 
-func (app *Globals) GetClientOpts() []client.ClientOpt {
+func (app *app) GetClientOpts() []client.ClientOpt {
 	opts := []client.ClientOpt{}
 
 	// Trace mode
@@ -104,3 +119,31 @@ func (app *Globals) GetClientOpts() []client.ClientOpt {
 	// Return options
 	return opts
 }
+
+///////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
+func hostName() string {
+	name, err := os.Hostname()
+	if err != nil {
+		panic(err)
+	}
+	return name
+}
+
+func userName() string {
+	user, err := user.Current()
+	if err != nil {
+		panic(err)
+	}
+	return user.Username
+}
+
+func execName() string {
+	// The name of the executable
+	name, err := os.Executable()
+	if err != nil {
+		panic(err)
+	}
+	return filepath.Base(name)
+}

pkg/logger/term.go

@@ -54,8 +54,9 @@ const (
 // PUBLIC METHODS
 
 func (h *TermHandler) Handle(ctx context.Context, r slog.Record) error {
-	level := r.Level.String() + ":"
-	label := ref.Label(ctx) + ":"
+	var parts []any
+
+	level := r.Level.String()
 	switch r.Level {
 	case slog.LevelDebug:
 		level = colorize(darkGray, level)
@@ -66,6 +67,12 @@ func (h *TermHandler) Handle(ctx context.Context, r slog.Record) error {
 	case slog.LevelError:
 		level = colorize(lightRed, level)
 	}
+	parts = append(parts, level+":")
+
+	label := ref.Label(ctx)
+	if label != "" {
+		parts = append(parts, label+":")
+	}
 
 	// Gather attributes
 	var data []byte
@@ -75,14 +82,10 @@ func (h *TermHandler) Handle(ctx context.Context, r slog.Record) error {
 		data = data_
 	}
 
+	parts = append(parts, colorize(white, r.Message), string(data))
+
 	// Print the message, return any errors
-	fmt.Fprintln(h.Writer,
-		colorize(lightGray, r.Time.Format(timeFormat)),
-		level,
-		label,
-		colorize(white, r.Message),
-		string(data),
-	)
+	fmt.Fprintln(h.Writer, parts...)
 	return nil
 }
 

pkg/parser/parser.go

@@ -32,7 +32,7 @@ func New(plugins ...server.Plugin) (*parser, error) {
 		name := plugin.Name()
 		if _, exists := p.meta[name]; exists {
 			return nil, httpresponse.ErrConflict.Withf("duplicate plugin: %q", name)
-		} else if meta, err := meta.New(plugin, name); err != nil {
+		} else if meta, err := meta.New(plugin); err != nil {
 			return nil, httpresponse.ErrInternalError.Withf("%s for %q", err, name)
 		} else {
 			p.meta[name] = meta
@@ -83,14 +83,17 @@ func (p *parser) jsonParse(root ast.Node) error {
 
 	// tree should contain <dict plugin:<dict values> plugin:<dict values> ...>
 	for _, plugins := range root.Children() {
+		if plugins.Type() != ast.Ident {
+			return httpresponse.ErrBadRequest.Withf("expected identifier, got %s", plugins.Type())
+		}
 		plugin := plugins.Value().(string)
-		if plugin, exists := p.meta[plugin]; !exists {
+		if plugin_, exists := p.meta[plugin]; !exists {
 			return httpresponse.ErrNotFound.Withf("plugin not found: %q", plugin)
 		} else if children := plugins.Children(); len(children) != 1 {
 			return httpresponse.ErrBadRequest.Withf("expected one child, got %d", len(children))
 		} else if dict := children[0]; dict.Type() != ast.Dict {
 			return httpresponse.ErrBadRequest.Withf("expected object, got %s", dict.Type())
-		} else if err := plugin.Validate(dict.Value()); err != nil {
+		} else if err := plugin_.Validate(dict.Value()); err != nil {
 			return err
 		}
 	}