Ejemplo n.º 1
0
func main() {
	flag.Parse()

	// Create a new Raven client
	var rc *raven.Client
	if *ravenDSN != "" {
		h, err := os.Hostname()
		if err != nil {
			log.Fatal(err)
		}

		rc, err = raven.NewClient(*ravenDSN, map[string]string{
			"hostname": h,
		})
		if err != nil {
			log.Fatal(err)
		}
	}

	defer func() {
		var packet *raven.Packet
		p := recover()
		switch rval := p.(type) {
		case nil:
			return
		case error:
			packet = raven.NewPacket(rval.Error(), raven.NewException(rval, raven.NewStacktrace(2, 3, nil)))
		default:
			rvalStr := fmt.Sprint(rval)
			packet = raven.NewPacket(rvalStr, raven.NewException(errors.New(rvalStr), raven.NewStacktrace(2, 3, nil)))
		}

		_, ch := rc.Capture(packet, nil)
		<-ch
		panic(p)
	}()

	config := &shared.Flags{
		EtcdAddress:      *etcdAddress,
		EtcdCAFile:       *etcdCAFile,
		EtcdCertFile:     *etcdCertFile,
		EtcdKeyFile:      *etcdKeyFile,
		EtcdPath:         *etcdPath,
		BindAddress:      *bindAddress,
		WelcomeMessage:   *welcomeMessage,
		Hostname:         *hostname,
		LogFormatterType: *logFormatterType,
		ForceColors:      *forceColors,
		RethinkAddress:   *rethinkdbAddress,
		RethinkKey:       *rethinkdbKey,
		RethinkDatabase:  *rethinkdbDatabase,
		NSQDAddress:      *nsqdAddress,
		LookupdAddress:   *lookupdAddress,
		SMTPAddress:      *smtpAddress,
		SpamdAddress:     *spamdAddress,
		DKIMKey:          *dkimKey,
		DKIMSelector:     *dkimSelector,
	}

	h := handler.PrepareHandler(config)

	server := &smtpd.Server{
		WelcomeMessage: *welcomeMessage,
		Handler:        h,
	}

	outbound.StartQueue(config)

	server.ListenAndServe(*bindAddress)
}
Ejemplo n.º 2
0
func main() {
	// Parse the flags
	flag.Parse()

	// Put config into the environment package
	env.Config = &env.Flags{
		BindAddress:      *bindAddress,
		APIVersion:       *apiVersion,
		LogFormatterType: *logFormatterType,
		ForceColors:      *forceColors,
		EmailDomain:      *emailDomain,

		SessionDuration: *sessionDuration,

		RedisAddress:  *redisAddress,
		RedisDatabase: *redisDatabase,
		RedisPassword: *redisPassword,

		RethinkDBAddress:  *rethinkdbAddress,
		RethinkDBKey:      *rethinkdbKey,
		RethinkDBDatabase: *rethinkdbDatabase,

		NSQdAddress:    *nsqdAddress,
		LookupdAddress: *lookupdAddress,

		YubiCloudID:  *yubiCloudID,
		YubiCloudKey: *yubiCloudKey,

		SlackURL:      *slackURL,
		SlackLevels:   *slackLevels,
		SlackChannel:  *slackChannel,
		SlackIcon:     *slackIcon,
		SlackUsername: *slackUsername,

		BloomFilter: *bloomFilter,
		BloomCount:  *bloomCount,

		RavenDSN: *ravenDSN,
	}

	// Generate a mux
	mux := setup.PrepareMux(env.Config)

	// Make the mux handle every request
	http.Handle("/", mux)

	// Log that we're starting the server
	env.Log.WithFields(logrus.Fields{
		"address": env.Config.BindAddress,
	}).Info("Starting the HTTP server")

	// Initialize the goroutine listening to signals passed to the app
	graceful.HandleSignals()

	// Pre-graceful shutdown event
	graceful.PreHook(func() {
		env.Log.Info("Received a singnal, stopping the application")
	})

	// Post-shutdown event
	graceful.PostHook(func() {
		env.Log.Info("Stopped the application")
	})

	// Listen to the passed address
	listener, err := net.Listen("tcp", env.Config.BindAddress)
	if err != nil {
		env.Log.WithFields(logrus.Fields{
			"error":   err,
			"address": *bindAddress,
		}).Fatal("Cannot set up a TCP listener")
	}

	// Start the listening
	err = graceful.Serve(listener, http.DefaultServeMux)
	if err != nil {
		// Don't use .Fatal! We need the code to shut down properly.
		env.Log.Error(err)
	}

	// If code reaches this place, it means that it was forcefully closed.

	// Wait until open connections close.
	graceful.Wait()
}