func main() {
brokerConfigPath := configPath()
log := lager.NewLogger("redis-configmigrator")
log.RegisterSink(lager.NewWriterSink(os.Stdout, lager.DEBUG))
log.RegisterSink(lager.NewWriterSink(os.Stderr, lager.ERROR))
log.Info("Config File: " + brokerConfigPath)
config, err := brokerconfig.ParseConfig(brokerConfigPath)
if err != nil {
log.Fatal("Loading config file", err, lager.Data{
"broker-config-path": brokerConfigPath,
})
}
migrator := &configmigrator.ConfigMigrator{
RedisDataDir: config.RedisConfiguration.InstanceDataDirectory,
}
err = migrator.Migrate()
if err != nil {
log.Fatal("Could not migrate data", err)
}
}
func LoadBrokerConfig(brokerFilename string) brokerconfig.Config {
brokerConfigPath := helpers.AssetPath(brokerFilename)
brokerConfig, err := brokerconfig.ParseConfig(brokerConfigPath)
Ω(err).NotTo(HaveOccurred())
return brokerConfig
}
func main() {
logger := lager.NewLogger("process-monitor")
logger.RegisterSink(lager.NewWriterSink(os.Stdout, lager.DEBUG))
logger.RegisterSink(lager.NewWriterSink(os.Stderr, lager.ERROR))
sigChannel := make(chan os.Signal, 1)
signal.Notify(sigChannel, syscall.SIGUSR1)
skipProcessCheck := false
go func() {
<-sigChannel
logger.Info("Trapped USR1, disabling process monitor")
skipProcessCheck = true
}()
config, err := brokerconfig.ParseConfig(configPath())
if err != nil {
logger.Fatal("could not parse config file", err, lager.Data{
"config-path": configPath(),
})
}
logger.Info("Starting process monitor")
repo := redis.NewLocalRepository(config.RedisConfiguration, logger)
commandRunner := system.OSCommandRunner{
Logger: logger,
}
processController := &redis.OSProcessController{
Logger: logger,
InstanceInformer: repo,
CommandRunner: commandRunner,
ProcessChecker: &process.ProcessChecker{},
ProcessKiller: &process.ProcessKiller{},
PingFunc: redis.PingServer,
WaitUntilConnectableFunc: availability.Check,
}
checkInterval := config.RedisConfiguration.ProcessCheckIntervalSeconds
instances, _ := repo.AllInstancesVerbose()
for _, instance := range instances {
copyConfigFile(instance, repo, logger)
}
for {
if skipProcessCheck {
logger.Info("Skipping instance check")
} else {
instances, _ := repo.AllInstances()
for _, instance := range instances {
ensureRunningIfNotLocked(instance, repo, processController, logger)
}
}
time.Sleep(time.Second * time.Duration(checkInterval))
}
}
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))
}
Describe("ParseConfig", func() {
var (
config brokerconfig.Config
configPath string
parseConfigErr error
)
BeforeEach(func() {
configPath = "test_config.yml"
})
JustBeforeEach(func() {
path, err := filepath.Abs(path.Join("assets", configPath))
Ω(err).ToNot(HaveOccurred())
config, parseConfigErr = brokerconfig.ParseConfig(path)
})
Context("when the configuration is valid", func() {
var dirs []string
BeforeEach(func() {
dirs = []string{"/tmp/to/redis", "/tmp/redis/data/directory", "/tmp/redis/log/directory"}
for _, dir := range dirs {
err := os.MkdirAll(dir, 0755)
Ω(err).ShouldNot(HaveOccurred())
}
_, err := os.Create("/tmp/to/redis/config.conf")
Ω(err).ShouldNot(HaveOccurred())
})
var dirs []string
var _ = BeforeSuite(func() {
helpers.ResetTestDirs()
dirs = []string{"/tmp/to/redis", "/tmp/redis/data/directory", "/tmp/redis/log/directory"}
for _, dir := range dirs {
err := os.MkdirAll(dir, 0755)
Ω(err).ShouldNot(HaveOccurred())
}
_, err := os.Create("/tmp/to/redis/config.conf")
Ω(err).ShouldNot(HaveOccurred())
path, err := filepath.Abs(path.Join("..", "brokerconfig", "assets", "test_config.yml"))
Ω(err).ToNot(HaveOccurred())
config, err := brokerconfig.ParseConfig(path)
Ω(err).NotTo(HaveOccurred())
logger := lager.NewLogger("foo")
repo, err := redis.NewRemoteRepository(&redis.RemoteAgentClient{}, config, logger)
Ω(err).NotTo(HaveOccurred())
handler := debug.NewHandler(repo)
http.HandleFunc("/debug", handler)
go func() {
defer GinkgoRecover()
err := http.ListenAndServe("localhost:3000", nil)
Expect(err).ToNot(HaveOccurred())
}()
