Example #1
0
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)
	}
}
Example #2
0
func LoadBrokerConfig(brokerFilename string) brokerconfig.Config {
	brokerConfigPath := helpers.AssetPath(brokerFilename)

	brokerConfig, err := brokerconfig.ParseConfig(brokerConfigPath)
	Ω(err).NotTo(HaveOccurred())

	return brokerConfig
}
Example #3
0
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))
	}
}
Example #4
0
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())
	}()