Merge pull request #86 from mutablelogic/v5

V5

Author: djthorpe

.gitignore

@@ -2,3 +2,6 @@ build
 _old
 ._*
 .DS_Store
+node_modules
+package-lock.json
+dist

Makefile

@@ -1,11 +1,13 @@
 # Executables
 GO ?= $(shell which go 2>/dev/null)
 DOCKER ?= $(shell which docker 2>/dev/null)
+NPM ?= $(shell which npm 2>/dev/null)
 
 # Locations
 BUILD_DIR ?= build
 CMD_DIR := $(wildcard cmd/*)
 PLUGIN_DIR := $(wildcard plugin/*)
+NPM_DIR := $(wildcard npm/*)
 
 # VERBOSE=1
 ifneq ($(VERBOSE),)
@@ -44,17 +46,20 @@ all: clean build
 
 # Build the commands in the cmd directory
 .PHONY: build
-build: tidy $(CMD_DIR) $(PLUGIN_DIR)
+build: tidy $(NPM_DIR) $(PLUGIN_DIR) $(CMD_DIR)
 
 $(CMD_DIR): go-dep mkdir
 	@echo Build command $(notdir $@) GOOS=${OS} GOARCH=${ARCH}
 	@GOOS=${OS} GOARCH=${ARCH} ${GO} build ${BUILD_FLAGS} -o ${BUILD_DIR}/$(notdir $@) ./$@
 
-
 $(PLUGIN_DIR): go-dep mkdir
 	@echo Build plugin $(notdir $@) GOOS=${OS} GOARCH=${ARCH}
 	@GOOS=${OS} GOARCH=${ARCH} ${GO} build -buildmode=plugin ${BUILD_FLAGS} -o ${BUILD_DIR}/$(notdir $@).plugin ./$@
 
+$(NPM_DIR): npm-dep
+	@echo Build npm $(notdir $@)
+	@cd $@ && npm install && npm run prod	
+
 # Build the docker image
 .PHONY: docker
 docker: docker-dep
@@ -122,3 +127,7 @@ go-dep:
 .PHONY: docker-dep
 docker-dep:
 	@test -f "${DOCKER}" && test -x "${DOCKER}"  || (echo "Missing docker binary" && exit 1)
+
+.PHONY: npm-dep
+npm-dep:
+	@test -f "${NPM}" && test -x "${NPM}"  || (echo "Missing npm binary" && exit 1)

cmd.go

@@ -0,0 +1,46 @@
+package server
+
+import (
+	"context"
+	"net/url"
+
+	// Packages
+	"github.com/mutablelogic/go-client"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// INTERFACES
+
+// Cmd represents the command line interface context
+type Cmd interface {
+	// Return the context
+	Context() context.Context
+
+	// Return the debug mode
+	GetDebug() DebugLevel
+
+	// Return the endpoint
+	GetEndpoint(paths ...string) *url.URL
+
+	// Return the HTTP client options
+	GetClientOpts() []client.ClientOpt
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type DebugLevel uint
+
+type CmdOffsetLimit struct {
+	Offset uint64  `name:"offset" help:"List item offset"`
+	Limit  *uint64 `name:"limit" help:"List item limit"`
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// GLOBALS
+
+const (
+	None DebugLevel = iota
+	Debug
+	Trace
+)

cmd/server/app.go

@@ -0,0 +1,106 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"syscall"
+
+	// Packages
+	kong "github.com/alecthomas/kong"
+	client "github.com/mutablelogic/go-client"
+	server "github.com/mutablelogic/go-server"
+	types "github.com/mutablelogic/go-server/pkg/types"
+	version "github.com/mutablelogic/go-server/pkg/version"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type Globals 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
+	ctx    context.Context
+	cancel context.CancelFunc
+}
+
+var _ server.Cmd = (*Globals)(nil)
+
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+func NewApp(app Globals, vars kong.Vars) (*Globals, error) {
+	// Set the vars
+	app.vars = vars
+
+	// 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
+}
+
+func (app *Globals) Close() error {
+	app.cancel()
+	return nil
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+func (app *Globals) Context() context.Context {
+	return app.ctx
+}
+
+func (app *Globals) GetDebug() server.DebugLevel {
+	if app.Debug {
+		return server.Debug
+	}
+	if app.Trace {
+		return server.Trace
+	}
+	return server.None
+}
+
+func (app *Globals) GetEndpoint(paths ...string) *url.URL {
+	url, err := url.Parse(app.Endpoint)
+	if err != nil {
+		return nil
+	}
+	for _, path := range paths {
+		url.Path = types.JoinPath(url.Path, os.Expand(path, func(key string) string {
+			return app.vars[key]
+		}))
+	}
+	return url
+}
+
+func (app *Globals) GetClientOpts() []client.ClientOpt {
+	opts := []client.ClientOpt{}
+
+	// Trace mode
+	if app.Debug || app.Trace {
+		opts = append(opts, client.OptTrace(os.Stderr, app.Trace))
+	}
+
+	// Append user agent
+	source := version.GitSource
+	version := version.GitTag
+	if source == "" {
+		source = "go-server"
+	}
+	if version == "" {
+		version = "v0.0.0"
+	}
+	opts = append(opts, client.OptUserAgent(fmt.Sprintf("%v/%v", filepath.Base(source), version)))
+
+	// Return options
+	return opts
+}

cmd/server/main.go

@@ -1,7 +1,98 @@
 package main
 
-import "fmt"
+import (
+	"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"
+	certmanager "github.com/mutablelogic/go-server/pkg/cert/cmd"
+	pgmanager "github.com/mutablelogic/go-server/pkg/pgmanager/cmd"
+	pgqueue "github.com/mutablelogic/go-server/pkg/pgqueue/cmd"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type CLI struct {
+	Globals
+	ServiceCommands
+	pgmanager.DatabaseCommands
+	pgmanager.SchemaCommands
+	pgmanager.ObjectCommands
+	pgmanager.RoleCommands
+	pgmanager.ConnectionCommands
+	pgmanager.TablespaceCommands
+	pgqueue.QueueCommands
+	pgqueue.TaskCommands
+	pgqueue.TickerCommands
+	certmanager.NameCommands
+	certmanager.CertCommands
+	auth.UserCommands
+	auth.TokenCommands
+	auth.AuthCommands
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
 
 func main() {
-	fmt.Println("Hello, World!")
+	// 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/v1",
+			"PG_PREFIX":    "/pg/v1",
+			"AUTH_PREFIX":  "/auth/v1",
+			"QUEUE_PREFIX": "/queue/v1",
+		},
+	)
+
+	// Create the app
+	app, err := NewApp(cli.Globals, kong.Model.Vars())
+	if err != nil {
+		kong.FatalIfErrorf(err)
+	}
+	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)
+	}
+	return filepath.Base(name)
 }