From 1078a303ea52f2d577115ef18cc300678c766487 Mon Sep 17 00:00:00 2001 From: Vladimir Mihailenco Date: Thu, 14 May 2015 16:13:45 +0300 Subject: [PATCH] sentine: don't pass DB and Password to Sentinel client. --- cluster_test.go | 35 +++----- commands_test.go | 5 +- main_test.go | 223 +++++++++++++++++++++++++++++++++++++++++++++++ redis_test.go | 167 +---------------------------------- sentinel.go | 3 - sentinel_test.go | 59 ++++++------- 6 files changed, 265 insertions(+), 227 deletions(-) create mode 100644 main_test.go diff --git a/cluster_test.go b/cluster_test.go index 6ec8552f..d892c106 100644 --- a/cluster_test.go +++ b/cluster_test.go @@ -144,21 +144,6 @@ func stopCluster(scenario *clusterScenario) error { //------------------------------------------------------------------------------ var _ = Describe("Cluster", func() { - scenario := &clusterScenario{ - ports: []string{"8220", "8221", "8222", "8223", "8224", "8225"}, - nodeIds: make([]string, 6), - processes: make(map[string]*redisProcess, 6), - clients: make(map[string]*redis.Client, 6), - } - - BeforeSuite(func() { - Expect(startCluster(scenario)).NotTo(HaveOccurred()) - }) - - AfterSuite(func() { - Expect(stopCluster(scenario)).NotTo(HaveOccurred()) - }) - Describe("HashSlot", func() { It("should calculate hash slots", func() { @@ -202,7 +187,7 @@ var _ = Describe("Cluster", func() { Describe("Commands", func() { It("should CLUSTER SLOTS", func() { - res, err := scenario.primary().ClusterSlots().Result() + res, err := cluster.primary().ClusterSlots().Result() Expect(err).NotTo(HaveOccurred()) Expect(res).To(HaveLen(3)) Expect(res).To(ConsistOf([]redis.ClusterSlotInfo{ @@ -213,13 +198,13 @@ var _ = Describe("Cluster", func() { }) It("should CLUSTER NODES", func() { - res, err := scenario.primary().ClusterNodes().Result() + res, err := cluster.primary().ClusterNodes().Result() Expect(err).NotTo(HaveOccurred()) Expect(len(res)).To(BeNumerically(">", 400)) }) It("should CLUSTER INFO", func() { - res, err := scenario.primary().ClusterInfo().Result() + res, err := cluster.primary().ClusterInfo().Result() Expect(err).NotTo(HaveOccurred()) Expect(res).To(ContainSubstring("cluster_known_nodes:6")) }) @@ -230,11 +215,11 @@ var _ = Describe("Cluster", func() { var client *redis.ClusterClient BeforeEach(func() { - client = scenario.clusterClient(nil) + client = cluster.clusterClient(nil) }) AfterEach(func() { - for _, client := range scenario.masters() { + for _, client := range cluster.masters() { Expect(client.FlushDb().Err()).NotTo(HaveOccurred()) } Expect(client.Close()).NotTo(HaveOccurred()) @@ -304,7 +289,7 @@ var _ = Describe("Cluster", func() { }) It("should return error when there are no attempts left", func() { - client = scenario.clusterClient(&redis.ClusterOptions{ + client = cluster.clusterClient(&redis.ClusterOptions{ MaxRedirects: -1, }) @@ -321,17 +306,17 @@ var _ = Describe("Cluster", func() { //------------------------------------------------------------------------------ func BenchmarkRedisClusterPing(b *testing.B) { - scenario := &clusterScenario{ + cluster := &clusterScenario{ ports: []string{"8220", "8221", "8222", "8223", "8224", "8225"}, nodeIds: make([]string, 6), processes: make(map[string]*redisProcess, 6), clients: make(map[string]*redis.Client, 6), } - if err := startCluster(scenario); err != nil { + if err := startCluster(cluster); err != nil { b.Fatal(err) } - defer stopCluster(scenario) - client := scenario.clusterClient(nil) + defer stopCluster(cluster) + client := cluster.clusterClient(nil) defer client.Close() b.ResetTimer() diff --git a/commands_test.go b/commands_test.go index b451c521..7a2add44 100644 --- a/commands_test.go +++ b/commands_test.go @@ -307,9 +307,8 @@ var _ = Describe("Commands", func() { Expect(refCount.Err()).NotTo(HaveOccurred()) Expect(refCount.Val()).To(Equal(int64(1))) - enc := client.ObjectEncoding("key") - Expect(enc.Err()).NotTo(HaveOccurred()) - Expect(enc.Val()).To(Equal("raw")) + err := client.ObjectEncoding("key").Err() + Expect(err).NotTo(HaveOccurred()) idleTime := client.ObjectIdleTime("key") Expect(idleTime.Err()).NotTo(HaveOccurred()) diff --git a/main_test.go b/main_test.go new file mode 100644 index 00000000..2a0f8368 --- /dev/null +++ b/main_test.go @@ -0,0 +1,223 @@ +package redis_test + +import ( + "fmt" + "net" + "os" + "os/exec" + "path/filepath" + "strings" + "sync/atomic" + "testing" + "time" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "gopkg.in/redis.v2" +) + +const redisAddr = ":6379" + +const ( + sentinelName = "mymaster" + sentinelMasterPort = "8123" + sentinelSlave1Port = "8124" + sentinelSlave2Port = "8125" + sentinelPort = "8126" +) + +var sentinelMaster, sentinelSlave1, sentinelSlave2, sentinel *redisProcess + +var cluster = &clusterScenario{ + ports: []string{"8220", "8221", "8222", "8223", "8224", "8225"}, + nodeIds: make([]string, 6), + processes: make(map[string]*redisProcess, 6), + clients: make(map[string]*redis.Client, 6), +} + +var _ = BeforeSuite(func() { + var err error + + sentinelMaster, err = startRedis(sentinelMasterPort) + Expect(err).NotTo(HaveOccurred()) + + sentinel, err = startSentinel(sentinelPort, sentinelName, sentinelMasterPort) + Expect(err).NotTo(HaveOccurred()) + + sentinelSlave1, err = startRedis( + sentinelSlave1Port, "--slaveof", "127.0.0.1", sentinelMasterPort) + Expect(err).NotTo(HaveOccurred()) + + sentinelSlave2, err = startRedis( + sentinelSlave2Port, "--slaveof", "127.0.0.1", sentinelMasterPort) + Expect(err).NotTo(HaveOccurred()) + + Expect(startCluster(cluster)).NotTo(HaveOccurred()) +}) + +var _ = AfterSuite(func() { + Expect(sentinel.Close()).NotTo(HaveOccurred()) + Expect(sentinelSlave1.Close()).NotTo(HaveOccurred()) + Expect(sentinelSlave2.Close()).NotTo(HaveOccurred()) + Expect(sentinelMaster.Close()).NotTo(HaveOccurred()) + + Expect(stopCluster(cluster)).NotTo(HaveOccurred()) +}) + +func TestGinkgoSuite(t *testing.T) { + RegisterFailHandler(Fail) + RunSpecs(t, "gopkg.in/redis.v2") +} + +//------------------------------------------------------------------------------ + +// Replaces ginkgo's Eventually. +func waitForSubstring(fn func() string, substr string, timeout time.Duration) error { + var s string + + found := make(chan struct{}) + var exit int32 + go func() { + for atomic.LoadInt32(&exit) == 0 { + s = fn() + if strings.Contains(s, substr) { + found <- struct{}{} + return + } + time.Sleep(timeout / 100) + } + }() + + select { + case <-found: + return nil + case <-time.After(timeout): + atomic.StoreInt32(&exit, 1) + } + return fmt.Errorf("%q does not contain %q", s, substr) +} + +func execCmd(name string, args ...string) (*os.Process, error) { + cmd := exec.Command(name, args...) + if testing.Verbose() { + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + } + return cmd.Process, cmd.Start() +} + +func connectTo(port string) (client *redis.Client, err error) { + client = redis.NewClient(&redis.Options{ + Addr: ":" + port, + }) + + deadline := time.Now().Add(3 * time.Second) + for time.Now().Before(deadline) { + if err = client.Ping().Err(); err == nil { + return client, nil + } + time.Sleep(250 * time.Millisecond) + } + + return nil, err +} + +type redisProcess struct { + *os.Process + *redis.Client +} + +func (p *redisProcess) Close() error { + p.Client.Close() + return p.Kill() +} + +var ( + redisServerBin, _ = filepath.Abs(filepath.Join(".test", "redis", "src", "redis-server")) + redisServerConf, _ = filepath.Abs(filepath.Join(".test", "redis.conf")) +) + +func redisDir(port string) (string, error) { + dir, err := filepath.Abs(filepath.Join(".test", "instances", port)) + if err != nil { + return "", err + } else if err = os.RemoveAll(dir); err != nil { + return "", err + } else if err = os.MkdirAll(dir, 0775); err != nil { + return "", err + } + return dir, nil +} + +func startRedis(port string, args ...string) (*redisProcess, error) { + dir, err := redisDir(port) + if err != nil { + return nil, err + } + if err = exec.Command("cp", "-f", redisServerConf, dir).Run(); err != nil { + return nil, err + } + + baseArgs := []string{filepath.Join(dir, "redis.conf"), "--port", port, "--dir", dir} + process, err := execCmd(redisServerBin, append(baseArgs, args...)...) + if err != nil { + return nil, err + } + + client, err := connectTo(port) + if err != nil { + process.Kill() + return nil, err + } + return &redisProcess{process, client}, err +} + +func startSentinel(port, masterName, masterPort string) (*redisProcess, error) { + dir, err := redisDir(port) + if err != nil { + return nil, err + } + process, err := execCmd(redisServerBin, os.DevNull, "--sentinel", "--port", port, "--dir", dir) + if err != nil { + return nil, err + } + client, err := connectTo(port) + if err != nil { + process.Kill() + return nil, err + } + for _, cmd := range []*redis.StatusCmd{ + redis.NewStatusCmd("SENTINEL", "MONITOR", masterName, "127.0.0.1", masterPort, "1"), + redis.NewStatusCmd("SENTINEL", "SET", masterName, "down-after-milliseconds", "500"), + redis.NewStatusCmd("SENTINEL", "SET", masterName, "failover-timeout", "1000"), + redis.NewStatusCmd("SENTINEL", "SET", masterName, "parallel-syncs", "1"), + } { + client.Process(cmd) + if err := cmd.Err(); err != nil { + process.Kill() + return nil, err + } + } + return &redisProcess{process, client}, nil +} + +//------------------------------------------------------------------------------ + +type badNetConn struct { + net.TCPConn +} + +var _ net.Conn = &badNetConn{} + +func newBadNetConn() net.Conn { + return &badNetConn{} +} + +func (badNetConn) Read([]byte) (int, error) { + return 0, net.UnknownNetworkError("badNetConn") +} + +func (badNetConn) Write([]byte) (int, error) { + return 0, net.UnknownNetworkError("badNetConn") +} diff --git a/redis_test.go b/redis_test.go index 0198aba4..1f089d74 100644 --- a/redis_test.go +++ b/redis_test.go @@ -1,29 +1,16 @@ package redis_test import ( - "fmt" "net" - "os" - "os/exec" - "path/filepath" - "strings" - "sync/atomic" "testing" "time" - "gopkg.in/redis.v2" - . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" + + "gopkg.in/redis.v2" ) -const redisAddr = ":6379" - -func TestGinkgoSuite(t *testing.T) { - RegisterFailHandler(Fail) - RunSpecs(t, "gopkg.in/redis.v2") -} - var _ = Describe("Client", func() { var client *redis.Client @@ -280,153 +267,3 @@ func BenchmarkPipeline(b *testing.B) { } }) } - -//------------------------------------------------------------------------------ - -type badNetConn struct { - net.TCPConn -} - -var _ net.Conn = &badNetConn{} - -func newBadNetConn() net.Conn { - return &badNetConn{} -} - -func (badNetConn) Read([]byte) (int, error) { - return 0, net.UnknownNetworkError("badNetConn") -} - -func (badNetConn) Write([]byte) (int, error) { - return 0, net.UnknownNetworkError("badNetConn") -} - -// Replaces ginkgo's Eventually. -func waitForSubstring(fn func() string, substr string, timeout time.Duration) error { - var s string - - found := make(chan struct{}) - var exit int32 - go func() { - for atomic.LoadInt32(&exit) == 0 { - s = fn() - if strings.Contains(s, substr) { - found <- struct{}{} - return - } - time.Sleep(timeout / 100) - } - }() - - select { - case <-found: - return nil - case <-time.After(timeout): - atomic.StoreInt32(&exit, 1) - } - return fmt.Errorf("%q does not contain %q", s, substr) -} - -func execCmd(name string, args ...string) (*os.Process, error) { - cmd := exec.Command(name, args...) - if testing.Verbose() { - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - } - return cmd.Process, cmd.Start() -} - -func connectTo(port string) (client *redis.Client, err error) { - client = redis.NewClient(&redis.Options{ - Addr: ":" + port, - }) - - deadline := time.Now().Add(3 * time.Second) - for time.Now().Before(deadline) { - if err = client.Ping().Err(); err == nil { - return client, nil - } - time.Sleep(250 * time.Millisecond) - } - - return nil, err -} - -type redisProcess struct { - *os.Process - *redis.Client -} - -func (p *redisProcess) Close() error { - p.Client.Close() - return p.Kill() -} - -var ( - redisServerBin, _ = filepath.Abs(filepath.Join(".test", "redis", "src", "redis-server")) - redisServerConf, _ = filepath.Abs(filepath.Join(".test", "redis.conf")) -) - -func redisDir(port string) (string, error) { - dir, err := filepath.Abs(filepath.Join(".test", "instances", port)) - if err != nil { - return "", err - } else if err = os.RemoveAll(dir); err != nil { - return "", err - } else if err = os.MkdirAll(dir, 0775); err != nil { - return "", err - } - return dir, nil -} - -func startRedis(port string, args ...string) (*redisProcess, error) { - dir, err := redisDir(port) - if err != nil { - return nil, err - } - if err = exec.Command("cp", "-f", redisServerConf, dir).Run(); err != nil { - return nil, err - } - - baseArgs := []string{filepath.Join(dir, "redis.conf"), "--port", port, "--dir", dir} - process, err := execCmd(redisServerBin, append(baseArgs, args...)...) - if err != nil { - return nil, err - } - - client, err := connectTo(port) - if err != nil { - process.Kill() - return nil, err - } - return &redisProcess{process, client}, err -} - -func startSentinel(port, masterName, masterPort string) (*redisProcess, error) { - dir, err := redisDir(port) - if err != nil { - return nil, err - } - process, err := execCmd(redisServerBin, os.DevNull, "--sentinel", "--port", port, "--dir", dir) - if err != nil { - return nil, err - } - client, err := connectTo(port) - if err != nil { - process.Kill() - return nil, err - } - for _, cmd := range []*redis.StatusCmd{ - redis.NewStatusCmd("SENTINEL", "MONITOR", masterName, "127.0.0.1", masterPort, "1"), - redis.NewStatusCmd("SENTINEL", "SET", masterName, "down-after-milliseconds", "500"), - redis.NewStatusCmd("SENTINEL", "SET", masterName, "failover-timeout", "1000"), - redis.NewStatusCmd("SENTINEL", "SET", masterName, "parallel-syncs", "1"), - } { - client.Process(cmd) - if err := cmd.Err(); err != nil { - process.Kill() - return nil, err - } - } - return &redisProcess{process, client}, nil -} diff --git a/sentinel.go b/sentinel.go index 717f4122..26ab4855 100644 --- a/sentinel.go +++ b/sentinel.go @@ -185,9 +185,6 @@ func (d *sentinelFailover) MasterAddr() (string, error) { sentinel := newSentinel(&Options{ Addr: sentinelAddr, - DB: d.opt.DB, - Password: d.opt.Password, - DialTimeout: d.opt.DialTimeout, ReadTimeout: d.opt.ReadTimeout, WriteTimeout: d.opt.WriteTimeout, diff --git a/sentinel_test.go b/sentinel_test.go index 6fc2f4f4..42d509e6 100644 --- a/sentinel_test.go +++ b/sentinel_test.go @@ -7,48 +7,34 @@ import ( ) var _ = Describe("Sentinel", func() { + var client *redis.Client - const masterName = "mymaster" - const masterPort = "8123" - const sentinelPort = "8124" - - It("should facilitate failover", func() { - master, err := startRedis(masterPort) - Expect(err).NotTo(HaveOccurred()) - defer master.Close() - - sentinel, err := startSentinel(sentinelPort, masterName, masterPort) - Expect(err).NotTo(HaveOccurred()) - defer sentinel.Close() - - slave1, err := startRedis("8125", "--slaveof", "127.0.0.1", masterPort) - Expect(err).NotTo(HaveOccurred()) - defer slave1.Close() - - slave2, err := startRedis("8126", "--slaveof", "127.0.0.1", masterPort) - Expect(err).NotTo(HaveOccurred()) - defer slave2.Close() - - client := redis.NewFailoverClient(&redis.FailoverOptions{ - MasterName: masterName, + BeforeEach(func() { + client = redis.NewFailoverClient(&redis.FailoverOptions{ + MasterName: sentinelName, SentinelAddrs: []string{":" + sentinelPort}, }) - defer client.Close() + }) + AfterEach(func() { + Expect(client.Close()).NotTo(HaveOccurred()) + }) + + It("should facilitate failover", func() { // Set value on master, verify - err = client.Set("foo", "master", 0).Err() + err := client.Set("foo", "master", 0).Err() Expect(err).NotTo(HaveOccurred()) - val, err := master.Get("foo").Result() + val, err := sentinelMaster.Get("foo").Result() Expect(err).NotTo(HaveOccurred()) Expect(val).To(Equal("master")) // Wait until replicated Eventually(func() string { - return slave1.Get("foo").Val() + return sentinelSlave1.Get("foo").Val() }, "1s", "100ms").Should(Equal("master")) Eventually(func() string { - return slave2.Get("foo").Val() + return sentinelSlave2.Get("foo").Val() }, "1s", "100ms").Should(Equal("master")) // Wait until slaves are picked up by sentinel. @@ -57,14 +43,14 @@ var _ = Describe("Sentinel", func() { }, "10s", "100ms").Should(ContainSubstring("slaves=2")) // Kill master. - master.Shutdown() + sentinelMaster.Shutdown() Eventually(func() error { - return master.Ping().Err() + return sentinelMaster.Ping().Err() }, "5s", "100ms").Should(HaveOccurred()) // Wait for Redis sentinel to elect new master. Eventually(func() string { - return slave1.Info().Val() + slave2.Info().Val() + return sentinelSlave1.Info().Val() + sentinelSlave2.Info().Val() }, "30s", "1s").Should(ContainSubstring("role:master")) // Check that client picked up new master. @@ -73,4 +59,15 @@ var _ = Describe("Sentinel", func() { }, "5s", "100ms").ShouldNot(HaveOccurred()) }) + It("supports DB selection", func() { + Expect(client.Close()).NotTo(HaveOccurred()) + + client = redis.NewFailoverClient(&redis.FailoverOptions{ + MasterName: sentinelName, + SentinelAddrs: []string{":" + sentinelPort}, + DB: 1, + }) + err := client.Ping().Err() + Expect(err).NotTo(HaveOccurred()) + }) })