Example of using fx for a short-lived CLI process?

[cweagans]

All of the information/examples that I can find about how to use Fx in the "correct" way are centered around long-lived processes (HTTP servers and the like). I really like how my application is structured with Fx, but I'm not quite sure how to use it for e.g. a CLI application that should be running for < 1 second.

For instance, is there any way to silence the log output entirely? Is there a way to default to not a long-running process?

[sywhang]

As of now, there isn't really a great way. Fx is designed to be more suitable for long-lived processes because it was mainly designed as a DI framework for microservices at Uber, which are, long-lived processes :).

Enabling fx to be more friendly for short-lived processes has been an ongoing discussion but there is no planned timeline on that happening.

[oakad]

Fx works quite well with short lived processes thanks to very handy Shutdowner interface. Yes, the boilerplate could be leaner, but the approach definitely woks.

[rhzs]

@oakad can you give us concrete working example?

[oakad]

package main

import (
	"fmt"
	"time"
	"context"

	"go.uber.org/fx"
)

type Action struct {
	sh fx.Shutdowner
}

func newAction(
	lc fx.Lifecycle,
	sh fx.Shutdowner,
) *Action {
	act := &Action{
		sh: sh,
	}

	lc.Append(fx.Hook{
		OnStart: act.start,
		OnStop:  act.stop,
	})

	return act
}

func (act *Action) start(ctx context.Context) error {
	go act.run()
	return nil
}

func (act *Action) stop(ctx context.Context) error {
	fmt.Println("Stopped")
	return nil
}

func (act *Action) run() {
	time.Sleep(time.Second)
	fmt.Println("Will stop now")
	act.sh.Shutdown()
}

func main() {
	fx.New(
		fx.Provide(
			newAction,
		),
		fx.Invoke(func(*Action) {}),
	).Run()
}

[anjolaoluwaakindipe]

package main

import (
	"fmt"
	"time"
	"context"

	"go.uber.org/fx"
)

type Action struct {
	sh fx.Shutdowner
}

func newAction(
	lc fx.Lifecycle,
	sh fx.Shutdowner,
) *Action {
	act := &Action{
		sh: sh,
	}

	lc.Append(fx.Hook{
		OnStart: act.start,
		OnStop:  act.stop,
	})

	return act
}

func (act *Action) start(ctx context.Context) error {
	go act.run()
	return nil
}

func (act *Action) stop(ctx context.Context) error {
	fmt.Println("Stopped")
	return nil
}

func (act *Action) run() {
	time.Sleep(time.Second)
	fmt.Println("Will stop now")
	act.sh.Shutdown()
}

func main() {
	fx.New(
		fx.Provide(
			newAction,
		),
		fx.Invoke(func(*Action) {}),
	).Run()
}

could this be added to the documentation for short-lived applications

[pespantelis]

Here's another workaround for short-lived processes:

package main

import (
	"context"
	"fmt"

	"go.uber.org/fx"
)

func Run(opts ...fx.Option) {
	app := fx.New(opts...)

	if err := app.Start(context.Background()); err != nil {
		fmt.Println("[Fx] START FAILED\t" + err.Error())
		return
	}
	if err := app.Stop(context.Background()); err != nil {
		fmt.Println("[Fx] STOP FAILED\t" + err.Error())
		return
	}

	fmt.Println("[Fx] DONE")
}

func main() {
	Run(
		fx.Invoke(func() {
			fmt.Println("--> Hello world!")
		}),
	)
}