func (cr *ClusterRunner) NewSession(sessionName string) *consuladapter.Session {
client := cr.NewClient()
adapter, err := consuladapter.NewSession(sessionName, 10*time.Second, client, consuladapter.NewSessionManager(client))
Expect(err).NotTo(HaveOccurred())
return adapter
}
func initializeReceptorBBS(etcdOptions *etcdstoreadapter.ETCDOptions, logger lager.Logger) Bbs.ReceptorBBS {
workPool, err := workpool.NewWorkPool(100)
if err != nil {
logger.Fatal("failed-to-construct-etcd-adapter-workpool", err, lager.Data{"num-workers": 100}) // should never happen
}
etcdAdapter, err := etcdstoreadapter.New(etcdOptions, workPool)
if err != nil {
logger.Fatal("failed-to-construct-etcd-tls-client", err)
}
client, err := consuladapter.NewClient(*consulCluster)
if err != nil {
logger.Fatal("new-client-failed", err)
}
sessionMgr := consuladapter.NewSessionManager(client)
consulSession, err := consuladapter.NewSession("receptor", *lockTTL, client, sessionMgr)
if err != nil {
logger.Fatal("consul-session-failed", err)
}
return Bbs.NewReceptorBBS(etcdAdapter, consulSession, *taskHandlerAddress, clock.NewClock(), logger)
}
func initializeLockMaintainer(
logger lager.Logger,
consulCluster, sessionName string,
lockTTL, lockRetryInterval time.Duration,
clock clock.Clock,
) ifrit.Runner {
client, err := consuladapter.NewClient(consulCluster)
if err != nil {
logger.Fatal("new-client-failed", err)
}
sessionMgr := consuladapter.NewSessionManager(client)
consulSession, err := consuladapter.NewSession(sessionName, lockTTL, client, sessionMgr)
if err != nil {
logger.Fatal("consul-session-failed", err)
}
uuid, err := uuid.NewV4()
if err != nil {
logger.Fatal("Couldn't generate uuid", err)
}
serviceClient := route_emitter.NewServiceClient(consulSession, clock)
return serviceClient.NewRouteEmitterLockRunner(logger, uuid.String(), lockRetryInterval)
}
func main() {
cf_debug_server.AddFlags(flag.CommandLine)
cf_lager.AddFlags(flag.CommandLine)
flag.Parse()
cf_http.Initialize(*communicationTimeout)
logger, reconfigurableSink := cf_lager.New("auctioneer")
initializeDropsonde(logger)
if err := validateBBSAddress(); err != nil {
logger.Fatal("invalid-bbs-address", err)
}
client, err := consuladapter.NewClient(*consulCluster)
if err != nil {
logger.Fatal("new-client-failed", err)
}
sessionMgr := consuladapter.NewSessionManager(client)
consulSession, err := consuladapter.NewSession("auctioneer", *lockTTL, client, sessionMgr)
if err != nil {
logger.Fatal("consul-session-failed", err)
}
clock := clock.NewClock()
bbsServiceClient := bbs.NewServiceClient(consulSession, clock)
auctioneerServiceClient := auctioneer.NewServiceClient(consulSession, clock)
auctionRunner := initializeAuctionRunner(logger, *cellStateTimeout, initializeBBSClient(logger), bbsServiceClient)
auctionServer := initializeAuctionServer(logger, auctionRunner)
lockMaintainer := initializeLockMaintainer(logger, auctioneerServiceClient)
members := grouper.Members{
{"lock-maintainer", lockMaintainer},
{"auction-runner", auctionRunner},
{"auction-server", auctionServer},
}
if dbgAddr := cf_debug_server.DebugAddress(flag.CommandLine); dbgAddr != "" {
members = append(grouper.Members{
{"debug-server", cf_debug_server.Runner(dbgAddr, reconfigurableSink)},
}, members...)
}
group := grouper.NewOrdered(os.Interrupt, members)
monitor := ifrit.Invoke(sigmon.New(group))
logger.Info("started")
err = <-monitor.Wait()
if err != nil {
logger.Error("exited-with-failure", err)
os.Exit(1)
}
logger.Info("exited")
}
func newFakeSessionManager(client *api.Client) *fakes.FakeSessionManager {
sessionMgr := &fakes.FakeSessionManager{}
realSM := consuladapter.NewSessionManager(client)
sessionMgr.NodeNameStub = realSM.NodeName
sessionMgr.NodeStub = realSM.Node
sessionMgr.CreateStub = realSM.Create
sessionMgr.CreateNoChecksStub = realSM.CreateNoChecks
sessionMgr.DestroyStub = realSM.Destroy
sessionMgr.RenewStub = realSM.Renew
sessionMgr.RenewPeriodicStub = realSM.RenewPeriodic
sessionMgr.NewLockStub = realSM.NewLock
return sessionMgr
}
func initializeConsulSession(logger lager.Logger) *consuladapter.Session {
client, err := consuladapter.NewClient(*consulCluster)
if err != nil {
logger.Fatal("new-client-failed", err)
}
sessionMgr := consuladapter.NewSessionManager(client)
consulSession, err := consuladapter.NewSession("converger", *lockTTL, client, sessionMgr)
if err != nil {
logger.Fatal("consul-session-failed", err)
}
return consulSession
}
func initializeServiceClient(logger lager.Logger) nsync.ServiceClient {
client, err := consuladapter.NewClient(*consulCluster)
if err != nil {
logger.Fatal("new-client-failed", err)
}
sessionMgr := consuladapter.NewSessionManager(client)
consulSession, err := consuladapter.NewSession("nsync-bulker", *lockTTL, client, sessionMgr)
if err != nil {
logger.Fatal("consul-session-failed", err)
}
return nsync.NewServiceClient(consulSession, clock.NewClock())
}
func initializeLocketClient(logger lager.Logger) locket.Client {
client, err := consuladapter.NewClient(*consulCluster)
if err != nil {
logger.Fatal("new-client-failed", err)
}
sessionMgr := consuladapter.NewSessionManager(client)
consulSession, err := consuladapter.NewSessionNoChecks(*sessionName, *lockTTL, client, sessionMgr)
if err != nil {
logger.Fatal("consul-session-failed", err)
}
return locket.NewClient(consulSession, clock.NewClock(), logger)
}
func main() {
cf_debug_server.AddFlags(flag.CommandLine)
cf_lager.AddFlags(flag.CommandLine)
etcdFlags := AddETCDFlags(flag.CommandLine)
encryptionFlags := encryption.AddEncryptionFlags(flag.CommandLine)
flag.Parse()
cf_http.Initialize(*communicationTimeout)
logger, reconfigurableSink := cf_lager.New("bbs")
logger.Info("starting")
initializeDropsonde(logger)
clock := clock.NewClock()
consulClient, err := consuladapter.NewClient(*consulCluster)
if err != nil {
logger.Fatal("new-consul-client-failed", err)
}
sessionManager := consuladapter.NewSessionManager(consulClient)
serviceClient := initializeServiceClient(logger, clock, consulClient, sessionManager)
cbWorkPool := taskworkpool.New(logger, *taskCallBackWorkers, taskworkpool.HandleCompletedTask)
keyManager, err := encryptionFlags.Validate()
if err != nil {
logger.Fatal("cannot-setup-encryption", err)
}
cryptor := encryption.NewCryptor(keyManager, rand.Reader)
etcdOptions, err := etcdFlags.Validate()
if err != nil {
logger.Fatal("etcd-validation-failed", err)
}
storeClient := initializeEtcdStoreClient(logger, etcdOptions)
db := initializeEtcdDB(logger, cryptor, storeClient, cbWorkPool, serviceClient)
migrationsDone := make(chan struct{})
maintainer := initializeLockMaintainer(logger, serviceClient)
migrationManager := migration.NewManager(logger,
db,
cryptor,
storeClient,
migrations.Migrations,
migrationsDone,
clock,
)
encryptor := encryptor.New(logger, db, keyManager, cryptor, storeClient, clock)
hub := events.NewHub()
watcher := watcher.NewWatcher(
logger,
db,
hub,
clock,
bbsWatchRetryWaitDuration,
)
handler := handlers.New(logger, db, hub, migrationsDone)
metricsNotifier := metrics.NewPeriodicMetronNotifier(
logger,
*reportInterval,
etcdOptions,
clock,
)
var server ifrit.Runner
if *requireSSL {
tlsConfig, err := cf_http.NewTLSConfig(*certFile, *keyFile, *caFile)
if err != nil {
logger.Fatal("tls-configuration-failed", err)
}
server = http_server.NewTLSServer(*listenAddress, handler, tlsConfig)
} else {
server = http_server.New(*listenAddress, handler)
}
members := grouper.Members{
{"lock-maintainer", maintainer},
{"workPool", cbWorkPool},
{"server", server},
{"migration-manager", migrationManager},
{"encryptor", encryptor},
{"watcher", watcher},
{"hub-closer", closeHub(logger.Session("hub-closer"), hub)},
{"metrics", *metricsNotifier},
}
if dbgAddr := cf_debug_server.DebugAddress(flag.CommandLine); dbgAddr != "" {
members = append(grouper.Members{
{"debug-server", cf_debug_server.Runner(dbgAddr, reconfigurableSink)},
}, members...)
}
group := grouper.NewOrdered(os.Interrupt, members)
monitor := ifrit.Invoke(sigmon.New(group))
logger.Info("started")
err = <-monitor.Wait()
if err != nil {
logger.Error("exited-with-failure", err)
os.Exit(1)
}
logger.Info("exited")
}