示例#1
0
func setupForwarders(ctx context.Context, loadedConfig *config.ProxyConfig) ([]protocol.Forwarder, error) {
	allForwarders := make([]protocol.Forwarder, 0, len(loadedConfig.ForwardTo))
	allKeepers := []stats.Keeper{stats.NewGolangKeeper()}
	for _, forwardConfig := range loadedConfig.ForwardTo {
		loader, ok := allForwarderLoaders[forwardConfig.Type]
		if !ok {
			log.WithField("type", forwardConfig.Type).Error("Unknown loader type")
			return nil, fmt.Errorf("unknown loader type %s", forwardConfig.Type)
		}
		forwarder, err := loader(ctx, forwardConfig)
		if err != nil {
			log.WithField("err", err).Error("unable to load config")
			return nil, err
		}
		allForwarders = append(allForwarders, forwarder)
		allKeepers = append(allKeepers, forwarder)
	}
	return allForwarders, nil
}
示例#2
0
func (proxyCommandLineConfiguration *proxyCommandLineConfigurationT) main() error {
	log.WithField("configFile", proxyCommandLineConfiguration.configFileName).Info("Looking for config file")
	log.WithField("env", strings.Join(os.Environ(), " -*- ")).Info("Current env at start")

	loadedConfig, err := config.Load(proxyCommandLineConfiguration.configFileName)
	if err != nil {
		log.WithField("err", err).Error("Unable to load config")
		return err
	}
	proxyCommandLineConfiguration.setupLogrus(loadedConfig)

	{
		pidFilename := proxyCommandLineConfiguration.pidFileName
		if loadedConfig.PidFilename != nil {
			pidFilename = *loadedConfig.PidFilename
		}
		writePidFile(pidFilename)
	}

	log.WithField("config", loadedConfig).Info("Config loaded")
	log.WithField("env", strings.Join(os.Environ(), " -*- ")).Info("Current env after loading config")
	if loadedConfig.NumProcs != nil {
		runtime.GOMAXPROCS(*loadedConfig.NumProcs)
	} else {
		numProcs := runtime.NumCPU()
		runtime.GOMAXPROCS(numProcs)
	}

	proxyCommandLineConfiguration.allForwarders, err = setupForwarders(proxyCommandLineConfiguration.ctx, loadedConfig)
	if err != nil {
		return err
	}
	allKeepers := []stats.Keeper{stats.NewGolangKeeper()}

	multiplexerCounter := &dpsink.Counter{}
	multiplexer := dpsink.FromChain(demultiplexer.New(recastToSinks(proxyCommandLineConfiguration.allForwarders)), dpsink.NextWrap(multiplexerCounter))

	allKeepers = append(allKeepers, stats.ToKeeper(multiplexerCounter, map[string]string{"location": "middle", "name": "proxy", "type": "demultiplexer"}))

	proxyCommandLineConfiguration.allListeners, err = setupListeners(proxyCommandLineConfiguration.ctx, loadedConfig, multiplexer)
	if err != nil {
		return err
	}
	// I wish I could do this, but golang doesn't allow append() of super/sub types
	// allKeepers = append(allKeepers, proxyCommandLineConfiguration.allListeners...)
	allKeepers = append(allKeepers, recastListenToKeeper(proxyCommandLineConfiguration.allListeners)...)

	for _, forwarder := range proxyCommandLineConfiguration.allForwarders {
		allKeepers = append(allKeepers, forwarder)
	}

	if loadedConfig.StatsDelayDuration != nil && *loadedConfig.StatsDelayDuration != 0 {
		proxyCommandLineConfiguration.statDrainThread = stats.NewDrainingThread(*loadedConfig.StatsDelayDuration, recastToSinks(proxyCommandLineConfiguration.allForwarders), allKeepers, proxyCommandLineConfiguration.ctx)
	} else {
		log.Info("Skipping stat keeping")
	}

	setupDebugServer(allKeepers, loadedConfig, proxyCommandLineConfiguration.pprofaddr)

	log.Infof("Setup done.  Blocking!")
	if proxyCommandLineConfiguration.closeWhenWaitingToStopChannel != nil {
		close(proxyCommandLineConfiguration.closeWhenWaitingToStopChannel)
	}
	_ = <-proxyCommandLineConfiguration.stopChannel
	return nil
}