func NewBBS(c BBSConfig) (bbs.Client, error) {
c.PopulateFromEnv()
err := c.Validate()
if err != nil {
return nil, err
}
if c.IsSecure() {
return bbs.NewSecureSkipVerifyClient(c.URL, c.CertFile, c.KeyFile, 0, 0)
} else {
return bbs.NewClient(c.URL), nil
}
}
func initializeBBSClient(logger lager.Logger) bbs.Client {
bbsURL, err := url.Parse(*bbsAddress)
if err != nil {
logger.Fatal("Invalid BBS URL", err)
}
if bbsURL.Scheme != "https" {
return bbs.NewClient(*bbsAddress)
}
bbsClient, err := bbs.NewSecureClient(*bbsAddress, *bbsCACert, *bbsClientCert, *bbsClientKey, *bbsClientSessionCacheSize, *bbsMaxIdleConnsPerHost)
if err != nil {
logger.Fatal("Failed to configure secure BBS client", err)
}
return bbsClient
}
9001+config.GinkgoConfig.ParallelNode*consulrunner.PortOffsetLength,
1,
"http",
)
logger = lagertest.NewTestLogger("test")
bbsPath = string(binaries["bbs"])
bbsAddress := fmt.Sprintf("127.0.0.1:%d", 13000+GinkgoParallelNode())
bbsURL = &url.URL{
Scheme: "http",
Host: bbsAddress,
}
bbsClient = bbs.NewClient(bbsURL.String())
auctioneerServer = ghttp.NewServer()
auctioneerServer.UnhandledRequestStatusCode = http.StatusAccepted
auctioneerServer.AllowUnhandledRequests = true
bbsArgs = bbstestrunner.Args{
Address: bbsAddress,
AdvertiseURL: bbsURL.String(),
AuctioneerAddress: auctioneerServer.URL(),
EtcdCluster: strings.Join(etcdRunner.NodeURLS(), ","),
ConsulCluster: consulRunner.ConsulCluster(),
EncryptionKeys: []string{"label:key"},
ActiveKeyLabel: "label",
}
)
etcdRunner.Start()
bbsAddress := fmt.Sprintf("127.0.0.1:%d", 13000+GinkgoParallelNode())
bbsBinPath = string(payload)
bbsArgs = bbsrunner.Args{
Address: bbsAddress,
AdvertiseURL: "http://" + bbsAddress,
AuctioneerAddress: "some-address",
EtcdCluster: etcdRunner.NodeURLS()[0],
ConsulCluster: consulRunner.ConsulCluster(),
EncryptionKeys: []string{"label:key"},
ActiveKeyLabel: "label",
}
bbsClient = bbs.NewClient("http://" + bbsAddress)
consulRunner.Start()
consulRunner.WaitUntilReady()
})
var _ = SynchronizedAfterSuite(func() {
consulRunner.Stop()
etcdRunner.KillWithFire()
}, func() {
gexec.CleanupBuildArtifacts()
})
var _ = BeforeEach(func() {
consulRunner.Reset()
bbsRunner = bbsrunner.New(bbsBinPath, bbsArgs)
func main() {
cf_debug_server.AddFlags(flag.CommandLine)
cf_lager.AddFlags(flag.CommandLine)
etcdFlags := etcdstoreadapter.AddFlags(flag.CommandLine)
flag.Parse()
cf_http.Initialize(*communicationTimeout)
logger, reconfigurableSink := cf_lager.New("receptor")
logger.Info("starting")
initializeDropsonde(logger)
etcdOptions, err := etcdFlags.Validate()
if err != nil {
logger.Fatal("etcd-validation-failed", err)
}
if err := validateNatsArguments(); err != nil {
logger.Error("invalid-nats-flags", err)
os.Exit(1)
}
if err := validateBBSAddress(); err != nil {
logger.Fatal("invalid-bbs-address", err)
}
legacyBBS := initializeReceptorBBS(etcdOptions, logger)
bbs := bbs.NewClient(*bbsAddress)
handler := handlers.New(bbs, legacyBBS, logger, *username, *password, *corsEnabled)
worker, enqueue := task_handler.NewTaskWorkerPool(bbs, logger)
taskHandler := task_handler.New(enqueue, logger)
members := grouper.Members{
{"server", http_server.New(*serverAddress, handler)},
{"worker", worker},
{"task-complete-handler", http_server.New(*taskHandlerAddress, taskHandler)},
}
if *registerWithRouter {
registration := initializeServerRegistration(logger)
natsClient := diegonats.NewClient()
members = append(members, grouper.Member{
Name: "background-heartbeat",
Runner: natbeat.NewBackgroundHeartbeat(natsClient, *natsAddresses, *natsUsername, *natsPassword, logger, registration),
})
}
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")
}
BBSAddress: bbsURL.String(),
}
})
SynchronizedAfterSuite(func() {
}, func() {
CleanupBuildArtifacts()
})
BeforeEach(func() {
etcdRunner.Start()
consulRunner.Start()
consulRunner.WaitUntilReady()
bbsProcess = ginkgomon.Invoke(bbsrunner.New(binPaths.Bbs, bbsArgs))
bbsClient = bbs.NewClient(fmt.Sprint("http://", bbsArgs.Address))
consulSession = consulRunner.NewSession("a-session")
capacity := models.NewCellCapacity(512, 1024, 124)
cellPresence := models.NewCellPresence("the-cell-id", "1.2.3.4", "the-zone", capacity, []string{}, []string{})
value, err := json.Marshal(cellPresence)
Expect(err).NotTo(HaveOccurred())
_, err = consulSession.SetPresence(bbs.CellSchemaPath(cellPresence.CellID), value)
Expect(err).NotTo(HaveOccurred())
})
AfterEach(func() {