func New(
logger, accessLogger lager.Logger,
updateWorkers int,
convergenceWorkersSize int,
db db.DB,
desiredHub, actualHub events.Hub,
taskCompletionClient taskworkpool.TaskCompletionClient,
serviceClient bbs.ServiceClient,
auctioneerClient auctioneer.Client,
repClientFactory rep.ClientFactory,
migrationsDone <-chan struct{},
exitChan chan struct{},
) http.Handler {
retirer := controllers.NewActualLRPRetirer(db, actualHub, repClientFactory, serviceClient)
pingHandler := NewPingHandler()
domainHandler := NewDomainHandler(db, exitChan)
actualLRPHandler := NewActualLRPHandler(db, exitChan)
actualLRPLifecycleHandler := NewActualLRPLifecycleHandler(db, db, actualHub, auctioneerClient, retirer, exitChan)
evacuationHandler := NewEvacuationHandler(db, db, db, actualHub, auctioneerClient, exitChan)
desiredLRPHandler := NewDesiredLRPHandler(updateWorkers, db, db, desiredHub, actualHub, auctioneerClient, repClientFactory, serviceClient, exitChan)
taskController := controllers.NewTaskController(db, taskCompletionClient, auctioneerClient, serviceClient, repClientFactory)
taskHandler := NewTaskHandler(taskController, exitChan)
eventsHandler := NewEventHandler(desiredHub, actualHub)
cellsHandler := NewCellHandler(serviceClient, exitChan)
emitter := middleware.NewLatencyEmitter(logger)
actions := rata.Handlers{
// Ping
bbs.PingRoute: emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, pingHandler.Ping)),
// Domains
bbs.DomainsRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, domainHandler.Domains))),
bbs.UpsertDomainRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, domainHandler.Upsert))),
// Actual LRPs
bbs.ActualLRPGroupsRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, actualLRPHandler.ActualLRPGroups))),
bbs.ActualLRPGroupsByProcessGuidRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, actualLRPHandler.ActualLRPGroupsByProcessGuid))),
bbs.ActualLRPGroupByProcessGuidAndIndexRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, actualLRPHandler.ActualLRPGroupByProcessGuidAndIndex))),
// Actual LRP Lifecycle
bbs.ClaimActualLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, actualLRPLifecycleHandler.ClaimActualLRP))),
bbs.StartActualLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, actualLRPLifecycleHandler.StartActualLRP))),
bbs.CrashActualLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, actualLRPLifecycleHandler.CrashActualLRP))),
bbs.RetireActualLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, actualLRPLifecycleHandler.RetireActualLRP))),
bbs.FailActualLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, actualLRPLifecycleHandler.FailActualLRP))),
bbs.RemoveActualLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, actualLRPLifecycleHandler.RemoveActualLRP))),
// Evacuation
bbs.RemoveEvacuatingActualLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, evacuationHandler.RemoveEvacuatingActualLRP))),
bbs.EvacuateClaimedActualLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, evacuationHandler.EvacuateClaimedActualLRP))),
bbs.EvacuateCrashedActualLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, evacuationHandler.EvacuateCrashedActualLRP))),
bbs.EvacuateStoppedActualLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, evacuationHandler.EvacuateStoppedActualLRP))),
bbs.EvacuateRunningActualLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, evacuationHandler.EvacuateRunningActualLRP))),
// Desired LRPs
bbs.DesiredLRPsRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, desiredLRPHandler.DesiredLRPs))),
bbs.DesiredLRPByProcessGuidRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, desiredLRPHandler.DesiredLRPByProcessGuid))),
bbs.DesiredLRPSchedulingInfosRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, desiredLRPHandler.DesiredLRPSchedulingInfos))),
bbs.DesireDesiredLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, desiredLRPHandler.DesireDesiredLRP))),
bbs.UpdateDesiredLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, desiredLRPHandler.UpdateDesiredLRP))),
bbs.RemoveDesiredLRPRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, desiredLRPHandler.RemoveDesiredLRP))),
bbs.DesiredLRPsRoute_r0: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, desiredLRPHandler.DesiredLRPs_r0))),
bbs.DesiredLRPsRoute_r1: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, desiredLRPHandler.DesiredLRPs_r1))),
bbs.DesiredLRPByProcessGuidRoute_r0: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, desiredLRPHandler.DesiredLRPByProcessGuid_r0))),
bbs.DesiredLRPByProcessGuidRoute_r1: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, desiredLRPHandler.DesiredLRPByProcessGuid_r1))),
bbs.DesireDesiredLRPRoute_r0: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, desiredLRPHandler.DesireDesiredLRP_r0))),
bbs.DesireDesiredLRPRoute_r1: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, desiredLRPHandler.DesireDesiredLRP_r1))),
// Tasks
bbs.TasksRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.Tasks))),
bbs.TaskByGuidRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.TaskByGuid))),
bbs.DesireTaskRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.DesireTask))),
bbs.StartTaskRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.StartTask))),
bbs.CancelTaskRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.CancelTask))),
bbs.FailTaskRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.FailTask))),
bbs.CompleteTaskRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.CompleteTask))),
bbs.ResolvingTaskRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.ResolvingTask))),
bbs.DeleteTaskRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.DeleteTask))),
bbs.TasksRoute_r1: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.Tasks_r1))),
bbs.TasksRoute_r0: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.Tasks_r0))),
bbs.TaskByGuidRoute_r1: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.TaskByGuid_r1))),
bbs.TaskByGuidRoute_r0: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.TaskByGuid_r0))),
bbs.DesireTaskRoute_r1: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.DesireTask_r1))),
bbs.DesireTaskRoute_r0: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, taskHandler.DesireTask_r0))),
// Events
bbs.EventStreamRoute_r0: route(middleware.LogWrap(logger, accessLogger, eventsHandler.Subscribe_r0)),
// Cells
bbs.CellsRoute: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, cellsHandler.Cells))),
bbs.CellsRoute_r1: route(emitter.EmitLatency(middleware.LogWrap(logger, accessLogger, cellsHandler.Cells))),
}
handler, err := rata.NewRouter(bbs.Routes, actions)
if err != nil {
panic("unable to create router: " + err.Error())
}
return middleware.RequestCountWrap(
UnavailableWrap(handler,
migrationsDone,
),
)
}
var (
logger *lagertest.TestLogger
loggableHandlerFunc middleware.LoggableHandlerFunc
)
BeforeEach(func() {
logger = lagertest.NewTestLogger("test-session")
logger.RegisterSink(lager.NewWriterSink(GinkgoWriter, lager.DEBUG))
loggableHandlerFunc = func(logger lager.Logger, w http.ResponseWriter, r *http.Request) {
logger = logger.Session("logger-group")
logger.Info("written-in-loggable-handler")
}
})
It("creates \"request\" session and passes it to LoggableHandlerFunc", func() {
handler := middleware.LogWrap(logger, nil, loggableHandlerFunc)
req, err := http.NewRequest("GET", "http://example.com", nil)
Expect(err).NotTo(HaveOccurred())
handler.ServeHTTP(nil, req)
Expect(logger.Buffer()).To(gbytes.Say("test-session.request.serving"))
Expect(logger.Buffer()).To(gbytes.Say("\"session\":\"1\""))
Expect(logger.Buffer()).To(gbytes.Say("test-session.request.logger-group.written-in-loggable-handler"))
Expect(logger.Buffer()).To(gbytes.Say("\"session\":\"1.1\""))
Expect(logger.Buffer()).To(gbytes.Say("test-session.request.done"))
Expect(logger.Buffer()).To(gbytes.Say("\"session\":\"1\""))
})
Context("with access loggger", func() {
var accessLogger *lagertest.TestLogger
BeforeEach(func() {
