// Run starts the Martini webapp handler
func (subway *Broker) Run() {
username := os.Getenv("SUBWAY_USERNAME")
if username == "" {
username = "******"
}
password := os.Getenv("SUBWAY_PASSWORD")
if password == "" {
password = "******"
}
credentials := brokerapi.BrokerCredentials{
Username: username,
Password: password,
}
fmt.Println(credentials)
port := os.Getenv("PORT")
if port == "" {
port = "3000"
}
brokerAPI := brokerapi.New(subway, subway.Logger, credentials)
http.Handle("/", brokerAPI)
subway.Logger.Fatal("http-listen", http.ListenAndServe(fmt.Sprintf("0.0.0.0:%s", port), nil))
}
func main() {
flag.Parse()
logger := lager.NewLogger("cf-rabbitmq-broker")
logger.RegisterSink(lager.NewWriterSink(os.Stdout, lager.INFO))
logger.RegisterSink(lager.NewWriterSink(os.Stderr, lager.ERROR))
rand.Seed(time.Now().UTC().UnixNano())
config, err := rabbitbroker.ReadConfig(configPath)
if err != nil {
logger.Fatal("read-config", err)
}
client, _ := rabbithole.NewClient(
fmt.Sprintf("http://%s:15672", config.Rabbitmq.Hosts[0]),
config.Rabbitmq.Administrator.Username,
config.Rabbitmq.Administrator.Password)
serviceBroker := rabbitbroker.New(config, client, rabbitbroker.RandomCredentialsGenerator{}, logger, rabbitbroker.BindingInfoResource{ProtocolInfo: rabbitbroker.ProtocolInfoResource{}})
credentials := brokerapi.BrokerCredentials{
Username: config.Service.Username,
Password: config.Service.Password,
}
http.Handle("/", brokerapi.New(serviceBroker, logger, credentials))
logger.Info("starting-server")
if err := http.ListenAndServe(":4567", nil); err != nil {
logger.Fatal("starting-server-failed", err)
}
}
func main() {
var err error
brokerConfig, err = config.LoadFromFile(*configFile)
if err != nil {
panic(fmt.Errorf("configuration load error from file %s. Err: %s", *configFile, err))
}
serviceBroker := &myServiceBroker{}
logger.RegisterSink(lager.NewWriterSink(os.Stdout, lager.DEBUG))
logger.Debug("config-load-success", lager.Data{"file-source": *configFile, "config": brokerConfig})
credentials := brokerapi.BrokerCredentials{
Username: "******",
Password: "******",
}
addr := getListeningAddr(brokerConfig)
brokerAPI := brokerapi.New(serviceBroker, logger, credentials)
http.Handle("/", brokerAPI)
http.ListenAndServe(addr, nil)
if err != nil {
logger.Error("error-listenting", err)
}
}
func main() {
var port string
serviceBroker := &myServiceBroker{}
logger := lager.NewLogger("my-service-broker")
credentials := brokerapi.BrokerCredentials{
Username: "******",
Password: "******",
}
port = os.Getenv("VCAP_APP_PORT")
brokerAPI := brokerapi.New(serviceBroker, logger, credentials)
http.Handle("/", brokerAPI)
http.ListenAndServe("0.0.0.0:"+port, nil)
}
func main() {
dbCreator := database.NewCreator("username", "password", "hostname", 123)
serviceBroker := &exampleServiceBroker{
dbCreator: dbCreator,
instances: map[string]string{},
}
logger := lager.NewLogger("cf-example-broker")
credentials := brokerapi.BrokerCredentials{
Username: "******",
Password: "******",
}
brokerAPI := brokerapi.New(serviceBroker, logger, credentials)
http.Handle("/", brokerAPI)
http.ListenAndServe(":3000", nil)
}
func main() {
ipAddress := os.Getenv("REDIS_IP")
serviceBroker := broker.New(broker.DatabaseIDs{}, ipAddress)
logger := lager.NewLogger("redis-service-broker")
credentials := brokerapi.BrokerCredentials{
Username: "******",
Password: "******",
}
brokerAPI := brokerapi.New(&serviceBroker, logger, credentials)
fmt.Println("Listening on port " + os.Getenv("PORT") + " with IP " + ipAddress)
http.Handle("/", brokerAPI)
if err := http.ListenAndServe(":"+os.Getenv("PORT"), nil); err != nil {
log.Fatal("ListenAndServe:", err)
}
}
func runMain(writer io.Writer) {
if !flag.Parsed() {
flag.Parse()
}
var err error
brokerConfig, err = config.LoadFromFile(*configFile)
if err != nil {
panic(fmt.Errorf("configuration load error from file %s. Err: %s", *configFile, err))
}
logger.RegisterSink(lager.NewWriterSink(writer, getLogLevel(brokerConfig)))
logger.Debug("config-load-success", lager.Data{"file-source": *configFile, "config": brokerConfig})
mssqlPars := brokerConfig.BrokerMssqlConnection
// set default sql driver if it is not set based on the OS
if _, ok := mssqlPars["driver"]; !ok && brokerConfig.BrokerGoSqlDriver == "odbc" {
if runtime.GOOS != "windows" {
mssqlPars["driver"] = "freetds"
} else {
mssqlPars["driver"] = "sql server"
}
}
mssqlProv = provisioner.NewMssqlProvisioner(logger, brokerConfig.BrokerGoSqlDriver, mssqlPars)
err = mssqlProv.Init()
if err != nil {
logger.Fatal("error-initializing-provisioner", err)
}
serviceBroker := &mssqlServiceBroker{}
brokerAPI := brokerapi.New(serviceBroker, logger, brokerConfig.Crednetials)
http.Handle("/", brokerAPI)
addr := getListeningAddr(brokerConfig)
logger.Info("start-listening", lager.Data{"addr": addr})
err = http.ListenAndServe(addr, exitOnPanicWrapper{http.DefaultServeMux})
if err != nil {
logger.Fatal("error-listening", err)
}
}
func main() {
sqlConn := ExtractDBSQL()
basicAuthInfo := ExtractBasicAuthInfo()
cloudControllerInfo := ExtractCloudControllerInfo()
lo.G.Debug("cloud controller", cloudControllerInfo)
chaos := chaospeddler.NewServiceBroker(
chaospeddler.NewMaestro(
cloudControllerInfo.Username,
cloudControllerInfo.Password,
cloudControllerInfo.LoginURL,
cloudControllerInfo.CCURL,
sqlConn,
),
)
chaos.Start()
logger := lager.NewLogger("chaos-peddler-servicebroker")
credentials := brokerapi.BrokerCredentials{
Username: basicAuthInfo.Username,
Password: basicAuthInfo.Password,
}
brokerAPI := brokerapi.New(chaos, logger, credentials)
http.Handle("/", brokerAPI)
http.ListenAndServe(":"+os.Getenv("PORT"), nil)
}
lastLogLine := func() lager.LogFormat {
if len(brokerLogger.Logs()) == 0 {
// better way to raise error?
err := errors.New("expected some log lines but there were none!")
Expect(err).NotTo(HaveOccurred())
}
return brokerLogger.Logs()[0]
}
BeforeEach(func() {
fakeServiceBroker = &fakes.FakeServiceBroker{
InstanceLimit: 3,
}
brokerLogger = lagertest.NewTestLogger("broker-api")
brokerAPI = brokerapi.New(fakeServiceBroker, brokerLogger, credentials)
})
Describe("respose headers", func() {
makeRequest := func() *httptest.ResponseRecorder {
recorder := httptest.NewRecorder()
request, _ := http.NewRequest("GET", "/v2/catalog", nil)
request.SetBasicAuth(credentials.Username, credentials.Password)
brokerAPI.ServeHTTP(recorder, request)
return recorder
}
It("has a Content-Type header", func() {
response := makeRequest()
header := response.Header().Get("Content-Type")
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))
}
