wire_gen.go

// Code generated by Wire. DO NOT EDIT.

//go:generate wire
//+build !wireinject

package main

import (
	"context"
	"contrib.go.opencensus.io/integrations/ocsql"
	"github.com/facebookincubator/symphony/pkg/log"
	"github.com/facebookincubator/symphony/pkg/server/metrics"
	"github.com/facebookincubator/symphony/pkg/server/xserver"
	"github.com/facebookincubator/symphony/pkg/telemetry"
	"github.com/net-auto/resourceManager/ent"
	"github.com/net-auto/resourceManager/graph/graphhttp"
	"github.com/net-auto/resourceManager/logging"
	"github.com/net-auto/resourceManager/viewer"
	"go.opencensus.io/stats/view"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"gocloud.dev/server/health"
)

import (
	_ "github.com/net-auto/resourceManager/ent/runtime"
)

// Injectors from wire.go:

func newApplication(ctx context.Context, flags *cliFlags) (*application, func(), error) {
	logger := provideLogger(ctx, flags)
	zapLogger := log.ProvideZapLogger(logger)
	psqlTenancy, err := newPsqlTenancy(ctx, flags)
	if err != nil {
		return nil, nil, err
	}
	tenancy, err := newTenancy(ctx, psqlTenancy)
	if err != nil {
		return nil, nil, err
	}
	config := flags.TelemetryConfig
	v := newHealthChecks(psqlTenancy)
	graphhttpConfig := graphhttp.Config{
		Tenancy:      tenancy,
		Logger:       logger,
		Telemetry:    config,
		HealthChecks: v,
	}
	server, cleanup, err := graphhttp.NewServer(graphhttpConfig)
	if err != nil {
		return nil, nil, err
	}
	string2 := flags.ListenAddress
	viewExporter, err := telemetry.ProvideViewExporter(config)
	if err != nil {
		cleanup()
		return nil, nil, err
	}
	v2 := provideViews()
	metricsConfig := metrics.Config{
		Log:      zapLogger,
		Exporter: viewExporter,
		Views:    v2,
	}
	metricsMetrics := metrics.New(metricsConfig)
	addr := flags.MetricsAddress
	mainApplication := &application{
		Logger:      zapLogger,
		server:      server,
		addr:        string2,
		metrics:     metricsMetrics,
		metricsAddr: addr,
	}
	return mainApplication, func() {
		cleanup()
	}, nil
}

// wire.go:

func newTenancy(ctx context.Context, tenancy *viewer.PsqlTenancy) (viewer.Tenancy, error) {
	initFunc := func(client *ent.Client) {

	}
	return viewer.NewCacheTenancy(tenancy, initFunc), nil
}

func newHealthChecks(tenancy *viewer.PsqlTenancy) []health.Checker {
	return []health.Checker{tenancy}
}

func newPsqlTenancy(ctx context.Context, flags *cliFlags) (*viewer.PsqlTenancy, error) {
	return viewer.NewPsqlTenancy(ctx, flags.DatabaseURL, flags.TenancyConfig.TenantMaxConn)
}

// Adapter exposing RM logger into symphony logger
type rmLoggerSymphonyAdapter struct {
	bg *zap.Logger
}

// Background returns a context-unaware logger.
func (l rmLoggerSymphonyAdapter) Background() *zap.Logger {
	return l.bg
}

// For returns a context-aware logger.
func (l rmLoggerSymphonyAdapter) For(ctx context.Context) *zap.Logger {
	return l.Background().With(log.FieldsFromContext(ctx)...)
}

// provideLogger initializes RM logger and exposes it to the wiring system as symphony logger
func provideLogger(ctx context.Context, cf *cliFlags) log.Logger {
	logging.Init(cf.LogPath, cf.LogLevel, cf.LogWithColors)
	var zapLevel zapcore.Level
	switch cf.LogLevel {
	case "trace":
	case "debug":
		zapLevel = zapcore.DebugLevel
		break
	case "warn":
		zapLevel = zapcore.WarnLevel
		break
	case "error":
		zapLevel = zapcore.ErrorLevel
		break
	case "panic":
		zapLevel = zapcore.PanicLevel
		break
	case "fatal":
		zapLevel = zapcore.FatalLevel
		break
	case "info":
	default:
		zapLevel = zapcore.InfoLevel
		break
	}
	zapLevel.Enabled(zap.DebugLevel)
	zapEncoder := zapcore.NewConsoleEncoder(zapcore.EncoderConfig{
		MessageKey:       "msg",
		LevelKey:         "",
		TimeKey:          "",
		NameKey:          "",
		CallerKey:        "",
		FunctionKey:      "",
		StacktraceKey:    "",
		LineEnding:       "",
		EncodeLevel:      nil,
		EncodeTime:       nil,
		EncodeDuration:   nil,
		EncodeCaller:     zapcore.ShortCallerEncoder,
		EncodeName:       zapcore.FullNameEncoder,
		ConsoleSeparator: " ",
	})
	core := zapcore.NewCore(zapEncoder, zapcore.AddSync(logging.GetLogger().Writer()), zapLevel)
	return rmLoggerSymphonyAdapter{zap.New(core)}
}

func provideViews() []*view.View {
	views := xserver.DefaultViews()
	views = append(views, ocsql.DefaultViews...)
	return views
}