chore(config/source/cli): Replace it with "cli", refs issue go-orb/go-orb#17

Author: jochumdev

README.md

@@ -18,6 +18,10 @@ The rps benchmark sends X bytes (default `1000`) to server which echoes it to th
 
 See the [WIKI](https://github.com/go-orb/go-orb/wiki/RPC-Benchmarks) for results.
 
+### [cmd/foobar](cmd/foobar)
+
+A example on howto run multiple services in a monolith.
+
 ### [event/simple](event/simple)
 
 A simple example of RPC requests over the event plugins, currently theres only the natsjs backend.
@@ -26,14 +30,26 @@ A simple example of RPC requests over the event plugins, currently theres only t
 
 A simple example of a go-orb service and client with an auth REST API.
 
-This example doesn't utilize the go-orb config system, just to show it's possible to configure a go-orb service without it.
+This example doesn't utilize the go-orb config system, just to show it's possible to configure a go-orb service without it. It has the smallest binary size of all examples.
 
 ### [rest/middleware](rest/middleware)
 
 A simple example of a go-orb service and client with a REST middleware.
 
 In it's [config](rest/middleware/config) folder you can find a variaty of config files for different transports as well as logging options and registries. All of them run with the same code/binary.
 
+Run the server with:
+
+```bash
+go run ./cmd/server/... --config ./config/grpc.yaml
+```
+
+And the client with:
+
+```bash
+go run ./cmd/client/... --config ./config/grpc.yaml
+```
+
 ## Running
 
 To run an example you need to have `go1.23.6` or later installed. You can get it with [gvm](https://github.com/moovweb/gvm).

benchmarks/event/cmd/handler/main.go

@@ -1,55 +1,40 @@
-// Package main contains a handler which acts as server for the request client.
+// Package main contains a simple handler/server example for a event run.
 package main
 
 import (
-	"context"
+	"fmt"
 	"os"
 
-	"github.com/go-orb/examples/benchmarks/event/pb/echo"
-	"github.com/go-orb/go-orb/event"
-	"github.com/go-orb/go-orb/log"
-	"github.com/go-orb/go-orb/types"
-	_ "github.com/go-orb/plugins/codecs/goccyjson"
+	"github.com/go-orb/go-orb/cli"
+	_ "github.com/go-orb/plugins/codecs/json"
 	_ "github.com/go-orb/plugins/codecs/proto"
-	_ "github.com/go-orb/plugins/config/source/cli/urfave"
 	_ "github.com/go-orb/plugins/event/natsjs"
 	_ "github.com/go-orb/plugins/log/slog"
 )
 
-func runner(
-	serviceName types.ServiceName,
-	serviceVersion types.ServiceVersion,
-	logger log.Logger,
-	eventWire event.Handler,
-	done chan os.Signal,
-) error {
-	echoHandler := func(_ context.Context, req *echo.Req) (*echo.Resp, error) {
-		return &echo.Resp{Payload: req.GetPayload()}, nil
+func main() {
+	app := cli.App{
+		Name:     "benchmarks.event.handler",
+		Version:  "",
+		Usage:    "A event benchmarking handler",
+		NoAction: false,
+		Flags: []*cli.Flag{
+			{
+				Name:        "log_level",
+				Default:     "INFO",
+				EnvVars:     []string{"LOG_LEVEL"},
+				ConfigPaths: []cli.FlagConfigPath{{Path: []string{"logger", "level"}}},
+				Usage:       "Set the log level, one of TRACE, DEBUG, INFO, WARN, ERROR",
+			},
+		},
+		Commands: []*cli.Command{},
 	}
 
-	ctx, cancel := context.WithCancel(context.Background())
-
-	event.HandleRequest(ctx, eventWire, "echo.echo", echoHandler)
-
-	logger.Info("Started", "name", serviceName, "version", serviceVersion)
-
-	// Blocks until sigterm/sigkill.
-	<-done
-
-	logger.Info("Stopping", "name", serviceName, "version", serviceVersion)
-
-	cancel()
-
-	return nil
-}
-
-func main() {
-	var (
-		serviceName    = types.ServiceName("benchmarks.event.handler")
-		serviceVersion = types.ServiceVersion("v0.0.1")
-	)
+	appContext := cli.NewAppContext(&app)
 
-	if _, err := run(serviceName, serviceVersion, runner); err != nil {
-		log.Error("while running", "err", err)
+	_, err := run(appContext, os.Args)
+	if err != nil {
+		fmt.Printf("run error: %s\n", err)
+		os.Exit(1)
 	}
 }

benchmarks/event/cmd/handler/wire.go

@@ -6,80 +6,80 @@ package main
 import (
 	"context"
 	"fmt"
-	"os"
-	"os/signal"
-	"syscall"
 
+	"github.com/go-orb/examples/benchmarks/event/pb/echo"
+	"github.com/go-orb/go-orb/cli"
 	"github.com/go-orb/go-orb/event"
 	"github.com/go-orb/go-orb/log"
 	"github.com/go-orb/go-orb/types"
-	"github.com/go-orb/plugins/config/source/cli/urfave"
+	"github.com/go-orb/plugins/cli/urfave"
 	"github.com/go-orb/wire"
 )
 
 // wireRunResult is here so "wire" has a type for the return value of wireRun.
-// wire needs a explicit type for each provider including "wireRun".
-type wireRunResult string
-
-// wireRunCallback is the actual code that runs the business logic.
-type wireRunCallback func(
-	serviceName types.ServiceName,
-	serviceVersion types.ServiceVersion,
-	logger log.Logger,
-	event event.Handler,
-	done chan os.Signal,
-) error
+type wireRunResult struct{}
 
 func wireRun(
-	serviceName types.ServiceName,
-	serviceVersion types.ServiceVersion,
+	serviceContext *cli.ServiceContext,
 	components *types.Components,
 	logger log.Logger,
-	event event.Handler,
-	cb wireRunCallback,
+	eventHandler event.Handler,
 ) (wireRunResult, error) {
 	// Orb start
 	for _, c := range components.Iterate(false) {
-		err := c.Start()
+		logger.Debug("Starting", "component", fmt.Sprintf("%s/%s", c.Type(), c.String()))
+
+		err := c.Start(serviceContext.Context())
 		if err != nil {
 			logger.Error("Failed to start", "error", err, "component", fmt.Sprintf("%s/%s", c.Type(), c.String()))
-			return "", err
+			return wireRunResult{}, fmt.Errorf("failed to start component %s/%s: %w", c.Type(), c.String(), err)
 		}
 	}
 
-	done := make(chan os.Signal, 1)
-	signal.Notify(done, syscall.SIGINT, syscall.SIGTERM)
-
 	//
 	// Actual code
-	runErr := cb(serviceName, serviceVersion, logger, event, done)
+	echoHandler := func(_ context.Context, req *echo.Req) (*echo.Resp, error) {
+		return &echo.Resp{Payload: req.GetPayload()}, nil
+	}
+
+	event.HandleRequest(serviceContext.Context(), eventHandler, "echo.echo", echoHandler)
+
+	// Blocks until interrupt
+	<-serviceContext.Context().Done()
 
 	// Orb shutdown.
 	ctx := context.Background()
 
 	for _, c := range components.Iterate(true) {
+		logger.Debug("Stopping", "component", fmt.Sprintf("%s/%s", c.Type(), c.String()))
+
 		err := c.Stop(ctx)
 		if err != nil {
 			logger.Error("Failed to stop", "error", err, "component", fmt.Sprintf("%s/%s", c.Type(), c.String()))
 		}
 	}
 
-	return "", runErr
+	return wireRunResult{}, nil
 }
 
-// run combines everything above and
 func run(
-	serviceName types.ServiceName,
-	serviceVersion types.ServiceVersion,
-	cb wireRunCallback,
+	appContext *cli.AppContext,
+	args []string,
 ) (wireRunResult, error) {
 	panic(wire.Build(
+		urfave.ProvideParser,
+		cli.ProvideParsedFlagsFromArgs,
+
+		cli.ProvideSingleServiceContext,
 		types.ProvideComponents,
-		urfave.ProvideConfigData,
-		wire.Value([]log.Option{}),
-		log.Provide,
-		wire.Value([]event.Option{}),
-		event.Provide,
+
+		cli.ProvideConfigData,
+		cli.ProvideServiceName,
+
+		log.ProvideNoOpts,
+
+		event.ProvideNoOpts,
+
 		wireRun,
 	))
 }