// Логгер в качестве исключения создадим заранее, потому что как правило что-то нужно писать в логи сразу, ещё до инициализации графа зависимостей.
logger := log.New(os.Stderr, "", 0)
logger.Print("Started")
container := dig.New() // создаём контейнер
// Регистрируем конструкторы.
// Dig во время запуска программы будет использовать рефлексию, чтобы по сигнатуре каждой функции понять, что она создаёт и что для этого требует.
_ = container.Provide(func() components.Logger {
    logger.Print("Provided logger")
    return logger // Прокинули уже созданный логгер.
})
_ = container.Provide(components.NewDBConn)
_ = container.Provide(components.NewHTTPServer)
_ = container.Invoke(func(_ *components.HTTPServer) {
    // Вызвали HTTPServer, как "корень" графа зависимостей, чтобы прогрузилось всё необходимое.
    logger.Print("Can work with HTTPServer")
    // Никаких средств для управления жизненным циклом нет, пришлось бы всё писать вручную.
})
/*
    Output:
    ---
    Started
    Provided logger
    New DBConn
    New HTTPServer
    Can work with HTTPServer
*/

ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// Логгер в качестве исключения создадим заранее, потому что как правило что-то нужно писать в логи сразу, ещё до
// инициализации графа зависимостей.
logger := log.New(os.Stderr, "", 0)
logger.Print("Started")
// На этот раз используем fx, здесь уже у нас появляется объект "приложения".
app := fx.New(
    fx.Provide(func() components.Logger {
        return logger // Добавляем логгер как внешний компонент.
    }),
    fx.Provide(
        func(logger components.Logger, lc fx.Lifecycle) *components.DBConn { // можем получить ещё и lc - жизненный цикл.
            conn := components.NewDBConn(logger)
            // Можно навесить хуки.
            lc.Append(fx.Hook{
                OnStart: func(ctx context.Context) error {
                    if err := conn.Connect(ctx); err != nil {
                        return fmt.Errorf("can't connect to db: %w", err)
                    }
                    return nil
                },
                OnStop: func(ctx context.Context) error {
                    return conn.Stop(ctx)
                },
            })
            return conn
        },
        func(logger components.Logger, dbConn *components.DBConn, lc fx.Lifecycle) *components.HTTPServer {
            s := components.NewHTTPServer(logger, dbConn)
            lc.Append(fx.Hook{
                OnStart: func(_ context.Context) error {
                    go func() {
                        defer cancel()
                        // Ассинхронно запускаем сервер, т.к. Serve - блокирующая операция.
                        if err := s.Serve(context.Background()); err != nil && !errors.Is(err, http.ErrServerClosed) {
                            logger.Print("Error: ", err)
                        }
                    }()
                    return nil
                },
                OnStop: func(ctx context.Context) error {
                    return s.Stop(ctx)
                },
            })
            return s
        },
    ),
    fx.Invoke(
        // Конструкторы - "ленивые", так что нужно будет вызвать корень графа зависимостей, чтобы прогрузилось всё необходимое.
        func(*components.HTTPServer) {
            go func() {
                components.AwaitSignal(ctx) // ожидаем сигнала, чтобы после этого завершить приложение.
                cancel()
            }()
        },
    ),
    fx.NopLogger,
)
_ = app.Start(ctx)
<-ctx.Done() // ожидаем завершения контекста в случае ошибки или получения сигнала
_ = app.Stop(context.Background())
/*
    Output:
    ---
    Started
    New DBConn
    New HTTPServer
    Connecting DBConn
    Connected DBConn
    Serving HTTPServer
    ^CStop HTTPServer
    Stopped HTTPServer
    Stop DBConn
    Stopped DBConn
*/

// +build wireinject
package main
import (
    "context"
    "github.com/google/wire"
    "github.com/vivid-money/article-golang-di/pkg/components"
)
func initializeHTTPServer(
    _ context.Context,
    _ components.Logger,
    closer func(), // функция, которая вызовет остановку всего приложения
) (
    res *components.HTTPServer,
    cleanup func(), // функция, которая остановит приложение
    err error,
) {
    wire.Build(
        NewDBConn,
        NewHTTPServer,
    )
    return &components.HTTPServer{}, nil, nil
}

func initializeHTTPServer(contextContext context.Context, logger components.Logger, closer func()) (*components.HTTPServer, func(), error) {
    dbConn, cleanup, err := NewDBConn(contextContext, logger)
    if err != nil {
        return nil, nil, err
    }
    httpServer, cleanup2 := NewHTTPServer(contextContext, logger, dbConn, closer)
    return httpServer, func() {
        cleanup2()
        cleanup()
    }, nil
}

package main
//go:generate wire
import (
    "context"
    "fmt"
    "log"
    "os"
    "errors"
    "net/http"
    "github.com/vivid-money/article-golang-di/pkg/components"
)
// Поскольку wire не поддерживает lifecycle (точнее, поддерживает только Cleanup-функции), а мы не хотим
// делать вызовы компонентов в нужном порядке руками, то придётся написать специальные врапперы для конструкторов,
// которые при этом будут при создании компонента начинать работу и возвращать cleanup-функцию для его остановки.
func NewDBConn(ctx context.Context, logger components.Logger) (*components.DBConn, func(), error) {
    conn := components.NewDBConn(logger)
    if err := conn.Connect(ctx); err != nil {
        return nil, nil, fmt.Errorf("can't connect to db: %w", err)
    }
    return conn, func() {
        if err := conn.Stop(context.Background()); err != nil {
            logger.Print("Error trying to stop dbconn", err)
        }
    }, nil
}
func NewHTTPServer(
    ctx context.Context,
    logger components.Logger,
    conn *components.DBConn,
    closer func(),
) (*components.HTTPServer, func()) {
    srv := components.NewHTTPServer(logger, conn)
    go func() {
        if err := srv.Serve(ctx); err != nil && !errors.Is(err, http.ErrServerClosed) {
            logger.Print("Error serving http: ", err)
        }
        closer()
    }()
    return srv, func() {
        if err := srv.Stop(context.Background()); err != nil {
            logger.Print("Error trying to stop http server", err)
        }
    }
}
func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    // Логгер в качестве исключения создадим заранее, потому что как правило что-то нужно писать в логи сразу, ещё до инициализации графа зависимостей.
    logger := log.New(os.Stderr, "", 0)
    logger.Print("Started")
    // Нужен способ остановить приложение по команде или в случае ошибки. Не хочется отменять "главный" кониекси, так
    // как он прекратит все Server'ы одновременно, что лишит смысла использование cleanup-функций. Поэтому мы будем
    // делать это на другом контексте.
    lifecycleCtx, cancelLifecycle := context.WithCancel(context.Background())
    defer cancelLifecycle()
    // Ничего не делаем с сервером, потому что вызываем Serve в конструкторах.
    _, cleanup, _ := initializeHTTPServer(ctx, logger, func() {
        cancelLifecycle()
    })
    defer cleanup()
    go func() {
        components.AwaitSignal(ctx) // ждём ошибки или сигнала
        cancelLifecycle()
    }()
    <-lifecycleCtx.Done()
    /*
        Output:
        ---
        New DBConn
        Connecting DBConn
        Connected DBConn
        New HTTPServer
        Serving HTTPServer
        ^CStop HTTPServer
        Stopped HTTPServer
        Stop DBConn
        Stopped DBConn
    */
}

logger := log.New(os.Stderr, "", 0)
dbConn := components.NewDBConn(logger)
httpServer := components.NewHTTPServer(logger, dbConn)
doSomething(httpServer)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    logger := log.New(os.Stderr, "", 0)
    logger.Print("Started")
    g, gCtx := errgroup.WithContext(ctx)
    dbConn := components.NewDBConn(logger)
    g.Go(func() error {
        // dbConn умеет останавливаться по отмене контекста.
        if err := dbConn.Connect(gCtx); err != nil {
            return fmt.Errorf("can't connect to db: %w", err)
        }
        return nil
    })
    httpServer := components.NewHTTPServer(logger, dbConn)
    g.Go(func() error {
        go func() {
            // предположим, что httpServer (как и http.ListenAndServe, кстати) не умеет останавливаться по отмене
            // контекста, тогда придётся добавить обработку отмены вручную.
            <-gCtx.Done()
            if err := httpServer.Stop(context.Background()); err != nil {
                logger.Print("Stopped http server with error:", err)
            }
        }()
        if err := httpServer.Serve(gCtx); err != nil && !errors.Is(err, http.ErrServerClosed) {
            return fmt.Errorf("can't serve http: %w", err)
        }
        return nil
    })
    go func() {
        components.AwaitSignal(gCtx)
        cancel()
    }()
    _ = g.Wait()
    /*
        Output:
        ---
        Started
        New DBConn
        New HTTPServer
        Connecting DBConn
        Connected DBConn
        Serving HTTPServer
        ^CStop HTTPServer
        Stop DBConn
        Stopped DBConn
        Stopped HTTPServer
        Finished serving HTTPServer
    */
}

ctx, cancel := context.WithCancel(context.Background())
defer cancel()
logger := log.New(os.Stderr, "", 0)
logger.Print("Started")
lc := lifecycle.NewLifecycle()
dbConn := components.NewDBConn(logger)
lc.AddServer(func(ctx context.Context) error { // просто регистриуем в правильном порядке серверы и шатдаунеры
    return dbConn.Connect(ctx)
}).AddShutdowner(func(ctx context.Context) error {
    return dbConn.Stop(ctx)
})
httpSrv := components.NewHTTPServer(logger, dbConn)
lc.Add(httpSrv) // потому что httpSrv реализует интерфейсы Server и Shutdowner
go func() {
    components.AwaitSignal(ctx)
    lc.Stop(context.Background())
}()
_ = lc.Serve(ctx)

a, err := NewA()
if err != nil {
    panic("cant create a: " + err.Error())
}
go a.Serve()
defer a.Stop()
b, err := NewB(a)
if err != nil {
    panic("cant create b: " + err.Error())
}
go b.Serve()
defer b.Stop()
/*
    Порядок старта: A, B
    Порядок остановки: B, A
*/

package main
import (
    "context"
    "fmt"
    "log"
    "os"
    "errors"
    "net/http"
    "github.com/vivid-money/article-golang-di/pkg/components"
)
func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    logger := log.New(os.Stderr, "", 0)
    logger.Print("Started")
    go func() {
        components.AwaitSignal(ctx)
        cancel()
    }()
    errset := &ErrSet{}
    errset.Add(runApp(ctx, logger, errset))
    _ = errset.Error() // можно обработать ошибку
    /*
        Output:
        ---
        Started
        New DBConn
        Connecting DBConn
        Connected DBConn
        New HTTPServer
        Serving HTTPServer
        ^CStop HTTPServer
        Stop DBConn
        Stopped DBConn
        Stopped HTTPServer
        Finished serving HTTPServer
    */
}
func runApp(ctx context.Context, logger components.Logger, errSet *ErrSet) error {
    var err error
    dbConn := components.NewDBConn(logger)
    if err := dbConn.Connect(ctx); err != nil {
        return fmt.Errorf("cant connect dbConn: %w", err)
    }
    defer Shutdown("dbConn", errSet, dbConn.Stop)
    httpServer := components.NewHTTPServer(logger, dbConn)
    if ctx, err = Serve(ctx, "httpServer", errSet, httpServer.Serve); err != nil && !errors.Is(err, http.ErrServerClosed) {
        return fmt.Errorf("cant serve httpServer: %w", err)
    }
    defer Shutdown("httpServer", errSet, httpServer.Stop)
    components.AwaitSignal(ctx)
    return ctx.Err()
}