"github.com/cloudfoundry-incubator/rep/evacuation/evacuation_context"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("EvacuationContext", func() {
var (
evacuatable evacuation_context.Evacuatable
evacuationReporter evacuation_context.EvacuationReporter
evacuationNotifier evacuation_context.EvacuationNotifier
)
BeforeEach(func() {
evacuatable, evacuationReporter, evacuationNotifier = evacuation_context.New()
})
Describe("Evacuatable", func() {
Context("when Evacuate has not been called", func() {
It("does not make the evacuation reporter return true for Evacuating", func() {
Expect(evacuationReporter.Evacuating()).To(BeFalse())
})
It("does not close the channel provided by the evacuation notifier", func() {
evacuateNotify := evacuationNotifier.EvacuateNotify()
Consistently(evacuateNotify).ShouldNot(BeClosed())
})
})
Context("when Evacuate has been called", func() {
bulker *harmonizer.Bulker
process ifrit.Process
)
BeforeEach(func() {
sender = fake.NewFakeMetricSender()
metrics.Initialize(sender, nil)
logger = lagertest.NewTestLogger("test")
pollInterval = 30 * time.Second
evacuationPollInterval = 10 * time.Second
fakeClock = fakeclock.NewFakeClock(time.Unix(123, 456))
fakeGenerator = new(fake_generator.FakeGenerator)
fakeQueue = new(fake_operationq.FakeQueue)
evacuatable, _, evacuationNotifier = evacuation_context.New()
bulker = harmonizer.NewBulker(logger, pollInterval, evacuationPollInterval, evacuationNotifier, fakeClock, fakeGenerator, fakeQueue)
})
JustBeforeEach(func() {
process = ifrit.Invoke(bulker)
Eventually(fakeClock.WatcherCount).Should(Equal(1))
})
AfterEach(func() {
process.Signal(os.Interrupt)
Eventually(process.Wait()).Should(Receive())
})
itPerformsBatchOperations := func() {
func main() {
cf_debug_server.AddFlags(flag.CommandLine)
cf_lager.AddFlags(flag.CommandLine)
stackMap := stackPathMap{}
supportedProviders := providers{}
flag.Var(&stackMap, "preloadedRootFS", "List of preloaded RootFSes")
flag.Var(&supportedProviders, "rootFSProvider", "List of RootFS providers")
flag.Parse()
cf_http.Initialize(*communicationTimeout)
logger, reconfigurableSink := cf_lager.New(*sessionName)
executorConfiguration := executorConfig()
if !executorinit.ValidateExecutor(logger, executorConfiguration) {
os.Exit(1)
}
initializeDropsonde(logger)
if *cellID == "" {
log.Fatalf("-cellID must be specified")
}
executorClient, executorMembers, err := executorinit.Initialize(logger, executorConfiguration)
if err != nil {
log.Fatalf("Failed to initialize executor: %s", err.Error())
}
defer executorClient.Cleanup()
if err := validateBBSAddress(); err != nil {
logger.Fatal("invalid-bbs-address", err)
}
locketClient := initializeLocketClient(logger)
clock := clock.NewClock()
evacuatable, evacuationReporter, evacuationNotifier := evacuation_context.New()
// only one outstanding operation per container is necessary
queue := operationq.NewSlidingQueue(1)
evacuator := evacuation.NewEvacuator(
logger,
clock,
executorClient,
evacuationNotifier,
*cellID,
*evacuationTimeout,
*evacuationPollingInterval,
)
bbsClient := initializeBBSClient(logger)
httpServer, address := initializeServer(bbsClient, executorClient, evacuatable, evacuationReporter, logger, rep.StackPathMap(stackMap), supportedProviders)
opGenerator := generator.New(*cellID, bbsClient, executorClient, evacuationReporter, uint64(evacuationTimeout.Seconds()))
preloadedRootFSes := []string{}
for k := range stackMap {
preloadedRootFSes = append(preloadedRootFSes, k)
}
members := grouper.Members{
{"http_server", httpServer},
{"presence", initializeCellPresence(address, locketClient, executorClient, logger, supportedProviders, preloadedRootFSes)},
{"bulker", harmonizer.NewBulker(logger, *pollingInterval, *evacuationPollingInterval, evacuationNotifier, clock, opGenerator, queue)},
{"event-consumer", harmonizer.NewEventConsumer(logger, opGenerator, queue)},
{"evacuator", evacuator},
}
members = append(executorMembers, members...)
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", lager.Data{"cell-id": *cellID})
err = <-monitor.Wait()
if err != nil {
logger.Error("exited-with-failure", err)
os.Exit(1)
}
logger.Info("exited")
}