func main() {
brokerConfigPath := configPath()
brokerLogger := lager.NewLogger("redis-broker")
brokerLogger.RegisterSink(lager.NewWriterSink(os.Stdout, lager.DEBUG))
brokerLogger.RegisterSink(lager.NewWriterSink(os.Stderr, lager.ERROR))
brokerLogger.Info("Starting CF Redis broker")
brokerLogger.Info("Config File: " + brokerConfigPath)
config, err := brokerconfig.ParseConfig(brokerConfigPath)
if err != nil {
brokerLogger.Fatal("Loading config file", err, lager.Data{
"broker-config-path": brokerConfigPath,
})
}
commandRunner := system.OSCommandRunner{
Logger: brokerLogger,
}
localRepo := redis.NewLocalRepository(config.RedisConfiguration, brokerLogger)
localRepo.AllInstancesVerbose()
processController := &redis.OSProcessController{
CommandRunner: commandRunner,
InstanceInformer: localRepo,
Logger: brokerLogger,
ProcessChecker: &process.ProcessChecker{},
ProcessKiller: &process.ProcessKiller{},
PingFunc: redis.PingServer,
WaitUntilConnectableFunc: availability.Check,
}
localCreator := &redis.LocalInstanceCreator{
FindFreePort: system.FindFreePort,
RedisConfiguration: config.RedisConfiguration,
ProcessController: processController,
LocalInstanceRepository: localRepo,
}
agentClient := &redis.RemoteAgentClient{
HttpAuth: config.AuthConfiguration,
}
remoteRepo, err := redis.NewRemoteRepository(agentClient, config, brokerLogger)
if err != nil {
brokerLogger.Fatal("Error initializing remote repository", err)
}
sigChannel := make(chan os.Signal, 1)
signal.Notify(sigChannel, syscall.SIGTERM)
go func() {
<-sigChannel
brokerLogger.Info("Starting Redis Broker shutdown")
localRepo.AllInstancesVerbose()
remoteRepo.StateFromFile()
os.Exit(0)
}()
serviceBroker := &broker.RedisServiceBroker{
InstanceCreators: map[string]broker.InstanceCreator{
"shared": localCreator,
"dedicated": remoteRepo,
},
InstanceBinders: map[string]broker.InstanceBinder{
"shared": localRepo,
"dedicated": remoteRepo,
},
Config: config,
}
brokerCredentials := brokerapi.BrokerCredentials{
Username: config.AuthConfiguration.Username,
Password: config.AuthConfiguration.Password,
}
brokerAPI := brokerapi.New(serviceBroker, brokerLogger, brokerCredentials)
authWrapper := auth.NewWrapper(brokerCredentials.Username, brokerCredentials.Password)
debugHandler := authWrapper.WrapFunc(debug.NewHandler(remoteRepo))
instanceHandler := authWrapper.WrapFunc(redisinstance.NewHandler(remoteRepo))
http.HandleFunc("/instance", instanceHandler)
http.HandleFunc("/debug", debugHandler)
http.Handle("/", brokerAPI)
brokerLogger.Fatal("http-listen", http.ListenAndServe(config.Host+":"+config.Port, nil))
}
logger.RegisterSink(lager.NewWriterSink(log, lager.DEBUG))
idLocator = id.DedicatedInstanceIDLocator(endpoint, clientUsername, clientPassword, logger)
actualInstanceID, instanceIDErr = idLocator.LocateID("", nodeIP)
expectedURL = fmt.Sprintf("%s?host=%s", endpoint, nodeIP)
})
Context("when the broker responds", func() {
BeforeEach(func() {
nodeIP = "8.8.8.8"
authWrapper := auth.NewWrapper(brokerUsername, brokerPassword)
instanceHandler := authWrapper.WrapFunc(redisinstance.NewHandler(&instanceFinder{
InstanceID: expectedInstanceID,
InstanceIP: nodeIP,
}))
server = httptest.NewServer(instanceHandler)
endpoint = server.URL
clientUsername = brokerUsername
clientPassword = brokerPassword
})
AfterEach(func() {
server.Close()
})
It("does not return an error", func() {
Expect(instanceIDErr).ToNot(HaveOccurred())
func (finder fakeInstanceFinder) IDForHost(host string) string {
return map[string]string{
"1.2.3.4": "1_2_3_4",
"9.8.7.6": "9_8_7_6",
}[host]
}
var _ = Describe("Redisinstance", func() {
var (
recorder *httptest.ResponseRecorder
handler http.HandlerFunc
)
BeforeEach(func() {
recorder = httptest.NewRecorder()
handler = redisinstance.NewHandler(fakeInstanceFinder{})
})
It("it responds with a 200", func() {
request, err := http.NewRequest("GET", "http://localhost/instances?host=1.2.3.4", nil)
Expect(err).NotTo(HaveOccurred())
handler.ServeHTTP(recorder, request)
Expect(recorder.Code).To(Equal(http.StatusOK))
})
It("returns the correct instance id for the host provided", func() {
request, err := http.NewRequest("GET", "http://localhost/instances?host=1.2.3.4", nil)
Expect(err).NotTo(HaveOccurred())
handler.ServeHTTP(recorder, request)