func main()

in scripts/testpop/testpop.go [56:131]
59 lines of code
15 McCabe index (conditional complexity)

func main() {
	verbose := flag.Bool("verbose", false, "enable debug level logging")
	flag.Parse()

	if !hostportPattern.MatchString(*hostport) {
		log.Fatalf("bad hostport: %s", *hostport)
	}

	ch, err := tchannel.NewChannel("ringpop", nil)
	if err != nil {
		log.Fatalf("could not create channel: %v", err)
	}

	logger := log.StandardLogger()
	if *verbose {
		logger.Level = log.DebugLevel
	}

	options := []ringpop.Option{ringpop.Channel(ch),
		ringpop.Address(*hostport),
		ringpop.Logger(bark.NewLoggerFromLogrus(logger)),

		ringpop.SuspectPeriod(time.Duration(*suspectPeriod) * time.Millisecond),
		ringpop.FaultyPeriod(time.Duration(*faultyPeriod) * time.Millisecond),
		ringpop.TombstonePeriod(time.Duration(*tombstonePeriod) * time.Millisecond),
	}

	if *identity != "" {
		options = append(options, ringpop.Identity(*identity))
	}

	if *statsUDP != "" && *statsFile != "" {
		log.Fatalf("-stats-udp and stats-file are mutually exclusive.")
	}

	if *statsUDP != "" || *statsFile != "" {
		var statsdClient statsd.Statter
		if *statsUDP != "" {
			var err error
			statsdClient, err = statsd.New(*statsUDP, "")
			if err != nil {
				log.Fatalf("colud not open stats connection: %v", err)
			}
		}

		if *statsFile != "" {
			statsdClient, err = NewFileStatsd(*statsFile)
			if err != nil {
				log.Fatalf("colud not open stats file: %v", err)
			}
		}

		statter := bark.NewStatsReporterFromCactus(statsdClient)
		options = append(options, ringpop.Statter(statter))
	}

	rp, _ := ringpop.New("ringpop", options...)

	if err := ch.ListenAndServe(*hostport); err != nil {
		log.Fatalf("could not listen on %s: %v", *hostport, err)
	}

	opts := &swim.BootstrapOptions{}
	opts.DiscoverProvider = jsonfile.New(*hostfile)

	_, err = rp.Bootstrap(opts)
	if err != nil {
		log.Fatalf("bootstrap failed: %v", err)
	}

	go signalHandler(rp, true)  // handle SIGINT
	go signalHandler(rp, false) // handle SIGTERM

	// block
	select {}
}