func main() { var configPath string flag.StringVar(&configPath, "config", "", "Path to redis config") flag.Parse() if configPath == "" { log.Fatal("Missing flag --config") } if _, err := os.Stat(configPath); os.IsNotExist(err) { log.Fatal("Redis config does not exist") } conf, err := redisconf.Load(configPath) if err != nil { log.Fatal("Invalid redis config") } _, err = client.Connect(client.Host(conf.Host()), client.Port(conf.Port())) if err != nil { log.Fatal("Can not connect to Redis") } m := metrics.Metrics{ metrics.Metric{ Name: "foo", Value: 1, Unit: "bar", }, } encoder := json.NewEncoder(os.Stdout) encoder.Encode(m) }
func (resetter *Resetter) ResetRedis() error { if err := resetter.stopRedis(); err != nil { return err } if err := resetter.deleteData(); err != nil { return err } if err := resetter.resetConfigWithNewPassword(); err != nil { return err } if err := resetter.startRedis(); err != nil { return err } conf, err := redisconf.Load(resetter.liveConfPath) if err != nil { return err } address, err := net.ResolveTCPAddr("tcp", "127.0.0.1:"+conf.Get("port")) if err != nil { return err } return resetter.portChecker.Check(address, resetter.timeout) }
func credentialsHandler(configPath string) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { conf, err := redisconf.Load(configPath) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } port, err := strconv.Atoi(conf.Get("port")) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } password := conf.Get("requirepass") credentials := struct { Port int `json:"port"` Password string `json:"password"` }{ Port: port, Password: password, } w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusOK) encoder := json.NewEncoder(w) encoder.Encode(credentials) } }
func startRedis(confPath string) (*gexec.Session, redis.Conn) { redisSession, err := gexec.Start(exec.Command("redis-server", confPath), GinkgoWriter, GinkgoWriter) Ω(err).ShouldNot(HaveOccurred()) conf, err := redisconf.Load(confPath) Ω(err).ShouldNot(HaveOccurred()) port, err := strconv.Atoi(conf.Get("port")) Ω(err).ShouldNot(HaveOccurred()) Expect(helpers.ServiceAvailable(uint(port))).To(BeTrue()) return redisSession, helpers.BuildRedisClient(uint(port), "localhost", conf.Get("requirepass")) }
func templateRedisConf(config *agentconfig.Config, logger lager.Logger) { newConfig, err := redisconf.Load(config.DefaultConfPath) if err != nil { logger.Fatal("Error loading default redis.conf", err, lager.Data{ "path": config.DefaultConfPath, }) } if fileExists(config.ConfPath) { existingConf, err := redisconf.Load(config.ConfPath) if err != nil { logger.Fatal("Error loading existing redis.conf", err, lager.Data{ "path": config.ConfPath, }) } err = newConfig.InitForDedicatedNode(existingConf.Password()) } else { err = newConfig.InitForDedicatedNode() } if err != nil { logger.Fatal("Error initializing redis conf for dedicated node", err) } err = newConfig.Save(config.ConfPath) if err != nil { logger.Fatal("Error saving redis.conf", err, lager.Data{ "path": config.ConfPath, }) } logger.Info("Finished writing redis.conf", lager.Data{ "path": config.ConfPath, "conf": newConfig, }) }
func (resetter *Resetter) resetConfigWithNewPassword() error { conf, err := redisconf.Load(resetter.defaultConfPath) if err != nil { return err } err = conf.InitForDedicatedNode() if err != nil { return err } if err := conf.Save(resetter.liveConfPath); err != nil { return err } return nil }
func (repo *LocalRepository) FindByID(instanceID string) (*Instance, error) { conf, err := redisconf.Load(repo.InstanceConfigPath(instanceID)) if err != nil { return nil, err } port, err := strconv.Atoi(conf.Get("port")) if err != nil { return nil, err } instance := &Instance{ ID: instanceID, Password: conf.Get("requirepass"), Port: port, Host: repo.RedisConf.Host, } return instance, nil }
func checkRedisStopAndStart(c chan<- bool) { defer GinkgoRecover() Eventually(redisSession, "3s").Should(gexec.Exit()) // Sleep here to emulate the time it takes monit to do it's thing time.Sleep(time.Millisecond * 200) var err error redisSession, err = gexec.Start(exec.Command("redis-server", redisConfPath), GinkgoWriter, GinkgoWriter) Ω(err).ShouldNot(HaveOccurred()) conf, err := redisconf.Load(redisConfPath) Ω(err).ShouldNot(HaveOccurred()) port, err := strconv.Atoi(conf.Get("port")) Ω(err).ShouldNot(HaveOccurred()) Expect(helpers.ServiceAvailable(uint(port))).To(BeTrue()) c <- true }
func (f *configFinder) Find() ([]RedisConfig, error) { paths, err := f.findFiles() if err != nil { return nil, err } redisConfigs := make([]RedisConfig, len(paths)) for i, path := range paths { config, err := redisconf.Load(path) if err != nil { return nil, err } redisConfigs[i] = RedisConfig{ Conf: config, Path: path, } } return redisConfigs, err }
func main() { var configPath string flag.StringVar(&configPath, "config", "", "Path to redis config file") flag.Parse() if configPath == "" { log.Fatal("Missing flag --config") } config, err := redisconf.Load(configPath) if err != nil { log.Fatalf("Error loading Redis config file: %s", err) } port := config.Port() host := config.Host() password := config.Password() clientConnection, err := client.Connect( client.Port(port), client.Host(host), client.Password(password), ) if err != nil { log.Fatalf("Error connecting to Redis: %s", err) } m, err := metrics.CPULoad(clientConnection) if err != nil { log.Fatalf("Error getting metrics: %s", err) } if err := json.NewEncoder(os.Stdout).Encode(m); err != nil { log.Fatalf("Error encoding json: %s", err) } }
func redisPIDProvider(instancePath string) process.PIDProvider { return func() (int, error) { instanceConf, err := redisconf.Load(path.Join(instancePath, "redis.conf")) if err != nil { return 0, err } client, err := client.Connect( client.Host("localhost"), client.Port(instanceConf.Port()), client.Password(instanceConf.Password()), client.CmdAliases(instanceConf.CommandAliases()), ) if err != nil { return 0, err } pidfile, err := client.GetConfig("pidfile") if err != nil { return 0, err } return process.ReadPID(pidfile) } }
func moveDataFor(propertyName, fileName, redisConfFilePath string) error { var fileContents []byte var redisConf redisconf.Conf var err error if redisConf, err = redisconf.Load(redisConfFilePath); err != nil { return err } if redisConf.Get(propertyName) != "" { os.Remove(fileName) return nil } if fileContents, err = ioutil.ReadFile(fileName); err != nil { return err } redisConf.Set(propertyName, string(fileContents)) if err = redisConf.Save(redisConfFilePath); err != nil { return err } os.Remove(fileName) return nil }
AfterEach(func() { stopAgent(agentSession) }) Context("when there is no redis.conf", func() { BeforeEach(func() { os.Remove(redisConfPath) agentSession = startAgent() }) loadRedisConfFileWhenItExists := func() redisconf.Conf { Eventually(func() bool { return helpers.FileExists(redisConfPath) }).Should(BeTrue()) conf, err := redisconf.Load(redisConfPath) Expect(err).ToNot(HaveOccurred()) return conf } It("copies a redis.conf from the default path and adds a password", func() { conf := loadRedisConfFileWhenItExists() Expect(conf.Get("daemonize")).To(Equal("no")) Expect(conf.HasKey("requirepass")).To(BeTrue()) }) It("creates a new password each time", func() { initialConf := loadRedisConfFileWhenItExists() helpers.KillProcess(agentSession)
var agentSession *gexec.Session var _ = Describe("DELETE /", func() { var ( redisConn redis.Conn aofPath string originalRedisConf redisconf.Conf ) BeforeEach(func() { agentSession = startAgent() redisSession, aofPath = startRedisAndBlockUntilUp() var err error originalRedisConf, err = redisconf.Load(redisConfPath) Ω(err).ShouldNot(HaveOccurred()) redisRestarted := make(chan bool) httpRequestReturned := make(chan bool) go checkRedisStopAndStart(redisRestarted) go doResetRequest(httpRequestReturned) select { case <-redisRestarted: <-httpRequestReturned case <-time.After(time.Second * 10): Fail("Test timed out after 10 seconds") }
configMigrator.Migrate() _, err := os.Stat(redisPortFilePath) Expect(os.IsNotExist(err)).To(BeTrue()) _, err = os.Stat(redisPasswordFilePath) Expect(os.IsNotExist(err)).To(BeTrue()) }) It("copies the port and password to redis.conf", func() { ioutil.WriteFile(redisConfFile, []byte("#port 63490"), 0777) ioutil.WriteFile(redisPortFilePath, []byte("3455"), 0777) ioutil.WriteFile(redisPasswordFilePath, []byte("secret-password"), 0777) configMigrator.Migrate() redisConfigValues, err := redisconf.Load(redisConfFile) Expect(err).ToNot(HaveOccurred()) Expect(redisConfigValues.Get("port")).To(Equal("3455")) Expect(redisConfigValues.Get("requirepass")).To(Equal("secret-password")) }) It("does not change the other values", func() { ioutil.WriteFile(redisConfFile, []byte("foo bar"), 0777) configMigrator.Migrate() redisConfigValues, err := redisconf.Load(redisConfFile) Expect(err).ToNot(HaveOccurred()) Expect(redisConfigValues.Get("foo")).To(Equal("bar")) })
os.Mkdir(redisInstanceDir, 0755) copyOverFromAssets("redis-server.port", redisInstanceDir) copyOverFromAssets("redis-server.password", redisInstanceDir) copyOverFromAssets("redis.conf", redisInstanceDir) executablePath := buildExecutable("github.com/pivotal-cf/cf-redis-broker/cmd/configmigrator") session := launchProcessWithBrokerConfig(executablePath, "broker.yml") session.Wait(10 * time.Second) Expect(session.ExitCode()).To(Equal(0)) _, err := os.Stat(path.Join(redisInstanceDir, "redis-server.port")) Expect(os.IsNotExist(err)).To(BeTrue()) _, err = os.Stat(path.Join(redisInstanceDir, "redis-server.password")) Expect(os.IsNotExist(err)).To(BeTrue()) redisConfValues, _ := redisconf.Load(path.Join(redisInstanceDir, "redis.conf")) Expect(redisConfValues.Get("port")).To(Equal("1234")) Expect(redisConfValues.Get("requirepass")).To(Equal("secret-password")) }) }) }) func copyOverFromAssets(fileName, dir string) { assetPath := helpers.AssetPath(fileName) data, _ := ioutil.ReadFile(assetPath) ioutil.WriteFile(path.Join(dir, fileName), data, 0644) } func buildExecutable(sourcePath string) string { executable, err := gexec.Build(sourcePath) if err != nil {
"strconv" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" "github.com/pivotal-cf/cf-redis-broker/redisconf" ) var _ = Describe("redisconf", func() { Describe("InitForDedicatedNode", func() { var conf redisconf.Conf BeforeEach(func() { path, err := filepath.Abs(path.Join("assets", "redis.conf")) Expect(err).ToNot(HaveOccurred()) conf, err = redisconf.Load(path) Expect(err).ToNot(HaveOccurred()) Expect(conf.Get("maxmemory")).To(BeEmpty()) Expect(conf.Password()).To(BeEmpty()) }) It("sets the max memory parameter", func() { err := conf.InitForDedicatedNode() Expect(err).ToNot(HaveOccurred()) maxmemory := conf.Get("maxmemory") Expect(maxmemory).ToNot(BeEmpty()) _, err = strconv.Atoi(maxmemory) Expect(err).ToNot(HaveOccurred()) })