Rename Master and Slave to Primary and Replica

Refactor SDL code not to use 'Master' and 'Slave' words in function
nor variable names due to their negative connotations.

Issue-Id: RIC-113

Signed-off-by: Timo Tietavainen <timo.tietavainen@nokia.com>
Change-Id: I3ecdcab4d8d36a6b8311fa34316d8ddbf71ae5a4

diff --git a/internal/cli/healthcheck.go b/internal/cli/healthcheck.go
index de78ba9..2ede93e 100644 (file)
--- a/internal/cli/healthcheck.go
+++ b/internal/cli/healthcheck.go
@@ -57,11 +57,11 @@ func runHealthCheck(dbCreateCb DbCreateCb) (string, error) {
        var str string
        var states []sdlgoredis.DbState
        for _, dbInst := range dbCreateCb().Instances {
-               info, err := dbInst.State()
+               state, err := dbInst.State()
                if err != nil {
                        anyErr = err
                }
-               states = append(states, *info)
+               states = append(states, *state)
        }
        str = writeStateResults(states)
        return str, anyErr
@@ -75,13 +75,15 @@ func writeStateResults(dbStates []sdlgoredis.DbState) string {
                        anyErr = err
                }
                str = str + fmt.Sprintf("  SDL DB backend #%d\n", (i+1))
-               mAddr := dbState.MasterDbState.GetAddress()
-               err := dbState.MasterDbState.IsOnline()
+
+               pAddr := dbState.PrimaryDbState.GetAddress()
+               err := dbState.PrimaryDbState.IsOnline()
                if err == nil {
-                       str = str + fmt.Sprintf("    Master (%s): OK\n", mAddr)
+                       str = str + fmt.Sprintf("    Primary (%s): OK\n", pAddr)
                } else {
-                       str = str + fmt.Sprintf("    Master (%s): NOK\n", mAddr)
+                       str = str + fmt.Sprintf("    Primary (%s): NOK\n", pAddr)
                        str = str + fmt.Sprintf("      %s\n", err.Error())
+
                }
                if dbState.ReplicasDbState != nil {
                        for j, rInfo := range dbState.ReplicasDbState.States {
@@ -93,6 +95,7 @@ func writeStateResults(dbStates []sdlgoredis.DbState) string {
                                        str = str + fmt.Sprintf("      %s\n", err.Error())
                                }
                        }
+
                }
                if dbState.SentinelsDbState != nil {
                        for k, sInfo := range dbState.SentinelsDbState.States {

diff --git a/internal/cli/healthcheck_test.go b/internal/cli/healthcheck_test.go
index 858385b..0de895a 100644 (file)
--- a/internal/cli/healthcheck_test.go
+++ b/internal/cli/healthcheck_test.go
@@ -40,12 +40,12 @@ type healthCheckMocks struct {
        dbState sdlgoredis.DbState
 }
 
-func setupHcMockMasterDb(ip, port string) {
+func setupHcMockPrimaryDb(ip, port string) {
        hcMocks = new(healthCheckMocks)
-       hcMocks.dbState.MasterDbState.Fields.Role = "master"
-       hcMocks.dbState.MasterDbState.Fields.Ip = ip
-       hcMocks.dbState.MasterDbState.Fields.Port = port
-       hcMocks.dbState.MasterDbState.Fields.Flags = "master"
+       hcMocks.dbState.PrimaryDbState.Fields.Role = "master"
+       hcMocks.dbState.PrimaryDbState.Fields.Ip = ip
+       hcMocks.dbState.PrimaryDbState.Fields.Port = port
+       hcMocks.dbState.PrimaryDbState.Fields.Flags = "master"
 }
 
 func setupHcMockReplicaDb(ip, port string) {
@@ -73,18 +73,18 @@ func setupHcMockSentinelDb(ip, port string) {
        }
 }
 
-func addHcMockReplicaDbState(ip, port, masterLinkOk string) {
+func addHcMockReplicaDbState(ip, port, primaryLinkOk string) {
        if hcMocks.dbState.ReplicasDbState == nil {
                hcMocks.dbState.ReplicasDbState = new(sdlgoredis.ReplicasDbState)
        }
        hcMocks.dbState.ReplicasDbState.States = append(hcMocks.dbState.ReplicasDbState.States,
                &sdlgoredis.ReplicaDbState{
                        Fields: sdlgoredis.ReplicaDbStateFields{
-                               Role:             "slave",
-                               Ip:               ip,
-                               Port:             port,
-                               MasterLinkStatus: masterLinkOk,
-                               Flags:            "slave",
+                               Role:              "slave",
+                               Ip:                ip,
+                               Port:              port,
+                               PrimaryLinkStatus: primaryLinkOk,
+                               Flags:             "slave",
                        },
                },
        )
@@ -154,7 +154,7 @@ func TestCliHealthCheckCanShowHelp(t *testing.T) {
 }
 
 func TestCliHealthCheckCanShowHaDeploymentOkStatusCorrectly(t *testing.T) {
-       setupHcMockMasterDb("10.20.30.40", "6379")
+       setupHcMockPrimaryDb("10.20.30.40", "6379")
        addHcMockReplicaDbState("1.2.3.4", "6379", "ok")
        addHcMockReplicaDbState("5.6.7.8", "6379", "ok")
        addHcMockSentinelDbState("1.2.3.4", "26379", "sentinel")
@@ -164,14 +164,14 @@ func TestCliHealthCheckCanShowHaDeploymentOkStatusCorrectly(t *testing.T) {
 
        assert.Nil(t, err)
        assert.Contains(t, stdout, "Overall status: OK")
-       assert.Contains(t, stdout, "Master (10.20.30.40:6379): OK")
+       assert.Contains(t, stdout, "Primary (10.20.30.40:6379): OK")
        assert.Contains(t, stdout, "Replica #1 (1.2.3.4:6379): OK")
        assert.Contains(t, stdout, "Replica #2 (5.6.7.8:6379): OK")
 
 }
 
 func TestCliHealthCheckCanShowHaDeploymentStatusCorrectlyWhenOneReplicaStateNotUp(t *testing.T) {
-       setupHcMockMasterDb("10.20.30.40", "6379")
+       setupHcMockPrimaryDb("10.20.30.40", "6379")
        addHcMockReplicaDbState("1.2.3.4", "6379", "ok")
        addHcMockReplicaDbState("5.6.7.8", "6379", "nok")
        addHcMockSentinelDbState("1.2.3.4", "26379", "sentinel")
@@ -182,11 +182,11 @@ func TestCliHealthCheckCanShowHaDeploymentStatusCorrectlyWhenOneReplicaStateNotU
        assert.Nil(t, err)
        assert.Contains(t, stdout, "Overall status: NOK")
        assert.Contains(t, stdout, "Replica #2 (5.6.7.8:6379): NOK")
-       assert.Contains(t, stdout, "Replica link to the master is down")
+       assert.Contains(t, stdout, "Replica link to the primary is down")
 }
 
 func TestCliHealthCheckCanShowHaDeploymentStatusCorrectlyWhenOneSentinelStateNotUp(t *testing.T) {
-       setupHcMockMasterDb("10.20.30.40", "6379")
+       setupHcMockPrimaryDb("10.20.30.40", "6379")
        addHcMockReplicaDbState("1.2.3.4", "6379", "ok")
        addHcMockReplicaDbState("5.6.7.8", "6379", "ok")
        addHcMockSentinelDbState("1.2.3.4", "26379", "some-failure")
@@ -203,7 +203,7 @@ func TestCliHealthCheckCanShowHaDeploymentStatusCorrectlyWhenOneSentinelStateNot
 }
 
 func TestCliHealthCheckCanShowHaDeploymentStatusCorrectlyWhenDbStateQueryFails(t *testing.T) {
-       setupHcMockMasterDb("10.20.30.40", "6379")
+       setupHcMockPrimaryDb("10.20.30.40", "6379")
        hcMocks.dbErr = errors.New("Some error")
 
        buf := new(bytes.Buffer)
@@ -224,7 +224,7 @@ func TestCliHealthCheckCanShowHaDeploymentOkStatusCorrectlyWhenDbStateIsFromRepl
 
        assert.Nil(t, err)
        assert.Contains(t, stdout, "Overall status: NOK")
-       assert.Contains(t, stdout, "Master (): NOK")
+       assert.Contains(t, stdout, "Primary (): NOK")
 }
 
 func TestCliHealthCheckCanShowHaDeploymentOkStatusCorrectlyWhenDbStateIsFromSentinelOnly(t *testing.T) {
@@ -234,15 +234,15 @@ func TestCliHealthCheckCanShowHaDeploymentOkStatusCorrectlyWhenDbStateIsFromSent
 
        assert.Nil(t, err)
        assert.Contains(t, stdout, "Overall status: NOK")
-       assert.Contains(t, stdout, "Master (): NOK")
+       assert.Contains(t, stdout, "Primary (): NOK")
 }
 
 func TestCliHealthCheckCanShowStandaloneDeploymentOkStatusCorrectly(t *testing.T) {
-       setupHcMockMasterDb("10.20.30.40", "6379")
+       setupHcMockPrimaryDb("10.20.30.40", "6379")
 
        stdout, err := runHcCli()
 
        assert.Nil(t, err)
        assert.Contains(t, stdout, "Overall status: OK")
-       assert.Contains(t, stdout, "Master (10.20.30.40:6379): OK")
+       assert.Contains(t, stdout, "Primary (10.20.30.40:6379): OK")
 }

diff --git a/internal/cli/namespaces.go b/internal/cli/namespaces.go
index d8c73ee..2f56533 100644 (file)
--- a/internal/cli/namespaces.go
+++ b/internal/cli/namespaces.go
@@ -97,7 +97,7 @@ func getServiceAddress(db iDatabase) (string, error) {
        if err != nil {
                return "", err
        }
-       return state.MasterDbState.GetAddress(), nil
+       return state.PrimaryDbState.GetAddress(), nil
 }
 
 func parseKeyNamespace(key string) (string, error) {

diff --git a/internal/cli/namespaces_test.go b/internal/cli/namespaces_test.go
index 65bec5f..7bff846 100644 (file)
--- a/internal/cli/namespaces_test.go
+++ b/internal/cli/namespaces_test.go
@@ -45,10 +45,10 @@ type nsMock struct {
 func setupNamespacesCliMock(keys []string, addr string, keysErr, stateErr error) {
        mNs = new(nsMock)
        mNs.dbKeys = keys
-       mNs.dbState.MasterDbState.Fields.Role = "Master"
-       mNs.dbState.MasterDbState.Fields.Ip = addr
+       mNs.dbState.PrimaryDbState.Fields.Role = "Primary"
+       mNs.dbState.PrimaryDbState.Fields.Ip = addr
        if addr != "" {
-               mNs.dbState.MasterDbState.Fields.Port = "6379"
+               mNs.dbState.PrimaryDbState.Fields.Port = "6379"
        }
        mNs.dbKeysErr = keysErr
        mNs.dbStateErr = stateErr

diff --git a/internal/sdlgoredis/dbinfo.go b/internal/sdlgoredis/dbinfo.go
index b8990e0..931cfb7 100644 (file)
--- a/internal/sdlgoredis/dbinfo.go
+++ b/internal/sdlgoredis/dbinfo.go
@@ -31,6 +31,6 @@ type DbInfo struct {
 //DbInfoFields struct is a holder for fields, which are read from sdlgoredis
 //'info' call's output.
 type DbInfoFields struct {
-       MasterRole          bool
+       PrimaryRole         bool
        ConnectedReplicaCnt uint32
 }

diff --git a/internal/sdlgoredis/dbstate.go b/internal/sdlgoredis/dbstate.go
index 61b6fdc..e3b9d0a 100644 (file)
--- a/internal/sdlgoredis/dbstate.go
+++ b/internal/sdlgoredis/dbstate.go
@@ -29,24 +29,24 @@ import (
 //DbState struct is a holder for DB state information, which is received from
 //sdlgoredis sentinel 'Master' and 'Slaves' calls output.
 type DbState struct {
-       MasterDbState    MasterDbState
+       PrimaryDbState   PrimaryDbState
        ReplicasDbState  *ReplicasDbState
        SentinelsDbState *SentinelsDbState
 }
 
-//MasterDbState struct is a holder for master Redis state information.
-type MasterDbState struct {
+//PrimaryDbState struct is a holder for primary Redis state information.
+type PrimaryDbState struct {
        Err    error
-       Fields MasterDbStateFields
+       Fields PrimaryDbStateFields
 }
 
-//ReplicasDbState struct is a holder for Redis slaves state information.
+//ReplicasDbState struct is a holder for Redis replicas state information.
 type ReplicasDbState struct {
        Err    error
        States []*ReplicaDbState
 }
 
-//ReplicaDbState struct is a holder for one Redis slave state information.
+//ReplicaDbState struct is a holder for one Redis replica state information.
 type ReplicaDbState struct {
        Fields ReplicaDbStateFields
 }
@@ -62,23 +62,23 @@ type SentinelDbState struct {
        Fields SentinelDbStateFields
 }
 
-//MasterDbStateFields struct is a holder for master Redis state information
+//PrimaryDbStateFields struct is a holder for primary Redis state information
 //fields which are read from sdlgoredis sentinel 'Master' call output.
-type MasterDbStateFields struct {
+type PrimaryDbStateFields struct {
        Role  string
        Ip    string
        Port  string
        Flags string
 }
 
-//ReplicaDbStateFields struct is a holder for slave Redis state information
+//ReplicaDbStateFields struct is a holder for replica Redis state information
 //fields which are read from sdlgoredis sentinel 'Slaves' call output.
 type ReplicaDbStateFields struct {
-       Role             string
-       Ip               string
-       Port             string
-       MasterLinkStatus string
-       Flags            string
+       Role              string
+       Ip                string
+       Port              string
+       PrimaryLinkStatus string
+       Flags             string
 }
 
 //SentinelDbStateFields struct is a holder for sentinel Redis state information
@@ -90,7 +90,7 @@ type SentinelDbStateFields struct {
 }
 
 func (dbst *DbState) IsOnline() error {
-       if err := dbst.MasterDbState.IsOnline(); err != nil {
+       if err := dbst.PrimaryDbState.IsOnline(); err != nil {
                return err
        }
        if dbst.ReplicasDbState != nil {
@@ -106,22 +106,22 @@ func (dbst *DbState) IsOnline() error {
        return nil
 }
 
-func (mdbst *MasterDbState) IsOnline() error {
-       if mdbst.Err != nil {
-               return mdbst.Err
+func (pdbst *PrimaryDbState) IsOnline() error {
+       if pdbst.Err != nil {
+               return pdbst.Err
        }
-       if mdbst.Fields.Role != "master" {
-               return fmt.Errorf("No master DB, current role '%s'", mdbst.Fields.Role)
+       if pdbst.Fields.Role != "master" {
+               return fmt.Errorf("No primary DB, current role '%s'", pdbst.Fields.Role)
        }
-       if mdbst.Fields.Flags != "master" {
-               return fmt.Errorf("Master flags are '%s', expected 'master'", mdbst.Fields.Flags)
+       if pdbst.Fields.Flags != "master" {
+               return fmt.Errorf("Primary flags are '%s', expected 'master'", pdbst.Fields.Flags)
        }
        return nil
 }
 
-func (mdbst *MasterDbState) GetAddress() string {
-       if mdbst.Fields.Ip != "" || mdbst.Fields.Port != "" {
-               return mdbst.Fields.Ip + ":" + mdbst.Fields.Port
+func (pdbst *PrimaryDbState) GetAddress() string {
+       if pdbst.Fields.Ip != "" || pdbst.Fields.Port != "" {
+               return pdbst.Fields.Ip + ":" + pdbst.Fields.Port
        } else {
                return ""
        }
@@ -144,8 +144,8 @@ func (rdbst *ReplicaDbState) IsOnline() error {
                return fmt.Errorf("Replica role is '%s', expected 'slave'", rdbst.Fields.Role)
        }
 
-       if rdbst.Fields.MasterLinkStatus != "ok" {
-               return fmt.Errorf("Replica link to the master is down")
+       if rdbst.Fields.PrimaryLinkStatus != "ok" {
+               return fmt.Errorf("Replica link to the primary is down")
        }
 
        if rdbst.Fields.Flags != "slave" {

diff --git a/internal/sdlgoredis/dbstate_test.go b/internal/sdlgoredis/dbstate_test.go
index cc32309..1727bbc 100644 (file)
--- a/internal/sdlgoredis/dbstate_test.go
+++ b/internal/sdlgoredis/dbstate_test.go
@@ -37,15 +37,15 @@ func setupDbState() *dbStateMock {
        return new(dbStateMock)
 }
 
-func (ds *dbStateMock) setMasterError(err error) {
-       ds.state.MasterDbState.Err = err
+func (ds *dbStateMock) setPrimaryError(err error) {
+       ds.state.PrimaryDbState.Err = err
 }
 
-func (ds *dbStateMock) setMasterFields(role, ip, port, rCnt, flags string) {
-       ds.state.MasterDbState.Fields.Role = role
-       ds.state.MasterDbState.Fields.Ip = ip
-       ds.state.MasterDbState.Fields.Port = port
-       ds.state.MasterDbState.Fields.Flags = flags
+func (ds *dbStateMock) setPrimaryFields(role, ip, port, rCnt, flags string) {
+       ds.state.PrimaryDbState.Fields.Role = role
+       ds.state.PrimaryDbState.Fields.Ip = ip
+       ds.state.PrimaryDbState.Fields.Port = port
+       ds.state.PrimaryDbState.Fields.Flags = flags
 }
 
 func (ds *dbStateMock) setReplicaError(err error) {
@@ -63,7 +63,7 @@ func (ds *dbStateMock) addReplicaFields(role, ip, port, mls, flags string) {
        newState.Fields.Role = role
        newState.Fields.Ip = ip
        newState.Fields.Port = port
-       newState.Fields.MasterLinkStatus = mls
+       newState.Fields.PrimaryLinkStatus = mls
        newState.Fields.Flags = flags
        ds.state.ReplicasDbState.States = append(ds.state.ReplicasDbState.States, newState)
 }
@@ -86,55 +86,55 @@ func (ds *dbStateMock) addSentinelFields(ip, port, flags string) {
        ds.state.SentinelsDbState.States = append(ds.state.SentinelsDbState.States, newState)
 }
 
-func TestIsOnlineWhenSingleMasterSuccessfully(t *testing.T) {
+func TestIsOnlineWhenSinglePrimarySuccessfully(t *testing.T) {
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "0", "master")
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "0", "master")
        err := st.state.IsOnline()
        assert.Nil(t, err)
 }
 
-func TestIsOnlineWhenSingleMasterFailureIfErrorHasSet(t *testing.T) {
+func TestIsOnlineWhenSinglePrimaryFailureIfErrorHasSet(t *testing.T) {
        testErr := errors.New("Some error")
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "0", "master")
-       st.setMasterError(testErr)
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "0", "master")
+       st.setPrimaryError(testErr)
        err := st.state.IsOnline()
        assert.Equal(t, testErr, err)
 }
 
-func TestIsOnlineWhenSingleMasterFailureIfNotMasterRole(t *testing.T) {
-       expErr := errors.New("No master DB, current role 'not-master'")
+func TestIsOnlineWhenSinglePrimaryFailureIfNotPrimaryRole(t *testing.T) {
+       expErr := errors.New("No primary DB, current role 'not-master'")
        st := setupDbState()
-       st.setMasterFields("not-master", "1.2.3.4", "60000", "0", "master")
+       st.setPrimaryFields("not-master", "1.2.3.4", "60000", "0", "master")
        err := st.state.IsOnline()
        assert.Equal(t, expErr, err)
 }
 
-func TestIsOnlineWhenSingleMasterFailureIfErrorFlags(t *testing.T) {
-       expErr := errors.New("Master flags are 'any-error,master', expected 'master'")
+func TestIsOnlineWhenSinglePrimaryFailureIfErrorFlags(t *testing.T) {
+       expErr := errors.New("Primary flags are 'any-error,master', expected 'master'")
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "0", "any-error,master")
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "0", "any-error,master")
        err := st.state.IsOnline()
        assert.Equal(t, expErr, err)
 }
 
-func TestGetAddressMasterSuccessfully(t *testing.T) {
+func TestGetAddressPrimarySuccessfully(t *testing.T) {
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "0", "master")
-       addr := st.state.MasterDbState.GetAddress()
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "0", "master")
+       addr := st.state.PrimaryDbState.GetAddress()
        assert.Equal(t, "1.2.3.4:60000", addr)
 }
 
-func TestGetAddressMasterFailureNoIpPort(t *testing.T) {
+func TestGetAddressPrimaryFailureNoIpPort(t *testing.T) {
        st := setupDbState()
-       st.setMasterFields("master", "", "", "0", "master")
-       addr := st.state.MasterDbState.GetAddress()
+       st.setPrimaryFields("master", "", "", "0", "master")
+       addr := st.state.PrimaryDbState.GetAddress()
        assert.Equal(t, "", addr)
 }
 
-func TestIsOnlineWhenMasterAndTwoReplicasSuccessfully(t *testing.T) {
+func TestIsOnlineWhenPrimaryAndTwoReplicasSuccessfully(t *testing.T) {
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "2", "master")
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "2", "master")
        st.addReplicaFields("slave", "6.7.8.9", "1234", "ok", "slave")
        st.addReplicaFields("slave", "6.7.8.10", "3450", "ok", "slave")
        st.addSentinelFields("6.7.8.9", "11234", "sentinel")
@@ -143,10 +143,10 @@ func TestIsOnlineWhenMasterAndTwoReplicasSuccessfully(t *testing.T) {
        assert.Nil(t, err)
 }
 
-func TestIsOnlineWhenMasterAndTwoReplicasFailureIfErrorHasSet(t *testing.T) {
+func TestIsOnlineWhenPrimaryAndTwoReplicasFailureIfErrorHasSet(t *testing.T) {
        testErr := errors.New("Some error")
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "2", "master")
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "2", "master")
        st.addReplicaFields("slave", "6.7.8.9", "1234", "ok", "slave")
        st.addReplicaFields("slave", "6.7.8.10", "3450", "ok", "slave")
        st.addSentinelFields("6.7.8.9", "11234", "sentinel")
@@ -156,10 +156,10 @@ func TestIsOnlineWhenMasterAndTwoReplicasFailureIfErrorHasSet(t *testing.T) {
        assert.Equal(t, testErr, err)
 }
 
-func TestIsOnlineWhenMasterAndOneReplicaFailureIfSentinelErrorHasSet(t *testing.T) {
+func TestIsOnlineWhenPrimaryAndOneReplicaFailureIfSentinelErrorHasSet(t *testing.T) {
        testErr := errors.New("Some error")
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "2", "master")
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "2", "master")
        st.addReplicaFields("slave", "6.7.8.9", "1234", "ok", "slave")
        st.addSentinelFields("6.7.8.9", "11234", "sentinel")
        st.setSentinelError(testErr)
@@ -167,10 +167,10 @@ func TestIsOnlineWhenMasterAndOneReplicaFailureIfSentinelErrorHasSet(t *testing.
        assert.Equal(t, testErr, err)
 }
 
-func TestIsOnlineWhenMasterAndTwoReplicasFailureIfNotSlaveRole(t *testing.T) {
+func TestIsOnlineWhenPrimaryAndTwoReplicasFailureIfNotReplicaRole(t *testing.T) {
        expErr := errors.New("Replica role is 'not-slave', expected 'slave'")
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "2", "master")
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "2", "master")
        st.addReplicaFields("slave", "6.7.8.9", "1234", "ok", "slave")
        st.addReplicaFields("not-slave", "6.7.8.10", "3450", "ok", "slave")
        st.addSentinelFields("6.7.8.9", "11234", "sentinel")
@@ -179,10 +179,10 @@ func TestIsOnlineWhenMasterAndTwoReplicasFailureIfNotSlaveRole(t *testing.T) {
        assert.Equal(t, expErr, err)
 }
 
-func TestIsOnlineWhenMasterAndTwoReplicasFailureIfMasterLinkDown(t *testing.T) {
-       expErr := errors.New("Replica link to the master is down")
+func TestIsOnlineWhenPrimaryAndTwoReplicasFailureIfPrimaryLinkDown(t *testing.T) {
+       expErr := errors.New("Replica link to the primary is down")
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "2", "master")
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "2", "master")
        st.addReplicaFields("slave", "6.7.8.9", "1234", "nok", "slave")
        st.addReplicaFields("slave", "6.7.8.10", "3450", "ok", "slave")
        st.addSentinelFields("6.7.8.9", "11234", "sentinel")
@@ -191,10 +191,10 @@ func TestIsOnlineWhenMasterAndTwoReplicasFailureIfMasterLinkDown(t *testing.T) {
        assert.Equal(t, expErr, err)
 }
 
-func TestIsOnlineWhenMasterAndTwoReplicasFailureIfErrorFlags(t *testing.T) {
+func TestIsOnlineWhenPrimaryAndTwoReplicasFailureIfErrorFlags(t *testing.T) {
        expErr := errors.New("Replica flags are 'any-error,slave', expected 'slave'")
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "2", "master")
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "2", "master")
        st.addReplicaFields("slave", "6.7.8.9", "1234", "ok", "slave")
        st.addReplicaFields("slave", "6.7.8.10", "3450", "ok", "any-error,slave")
        st.addSentinelFields("6.7.8.9", "11234", "sentinel")
@@ -203,10 +203,10 @@ func TestIsOnlineWhenMasterAndTwoReplicasFailureIfErrorFlags(t *testing.T) {
        assert.Equal(t, expErr, err)
 }
 
-func TestIsOnlineWhenMasterAndOneReplicaFailureIfSentinelErrorFlags(t *testing.T) {
+func TestIsOnlineWhenPrimaryAndOneReplicaFailureIfSentinelErrorFlags(t *testing.T) {
        expErr := errors.New("Sentinel flags are 'any-error,sentinel', expected 'sentinel'")
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "2", "master")
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "2", "master")
        st.addReplicaFields("slave", "6.7.8.9", "1234", "ok", "slave")
        st.addSentinelFields("6.7.8.9", "112345", "any-error,sentinel")
        err := st.state.IsOnline()
@@ -215,7 +215,7 @@ func TestIsOnlineWhenMasterAndOneReplicaFailureIfSentinelErrorFlags(t *testing.T
 
 func TestGetAddressReplicasSuccessfully(t *testing.T) {
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "2", "master")
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "2", "master")
        st.addReplicaFields("slave", "6.7.8.9", "1234", "ok", "slave")
        st.addReplicaFields("slave", "6.7.8.10", "3450", "ok", "slave")
        st.addSentinelFields("6.7.8.9", "11234", "sentinel")
@@ -228,7 +228,7 @@ func TestGetAddressReplicasSuccessfully(t *testing.T) {
 
 func TestGetAddressReplicasNoIpPort(t *testing.T) {
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "2", "master")
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "2", "master")
        st.addReplicaFields("slave", "", "", "ok", "slave")
        st.addReplicaFields("slave", "6.7.8.10", "3450", "ok", "slave")
        st.addSentinelFields("6.7.8.9", "11234", "sentinel")
@@ -241,7 +241,7 @@ func TestGetAddressReplicasNoIpPort(t *testing.T) {
 
 func TestGetAddressSentinelsSuccessfully(t *testing.T) {
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "2", "master")
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "2", "master")
        st.addReplicaFields("slave", "6.7.8.9", "1234", "ok", "slave")
        st.addReplicaFields("slave", "6.7.8.10", "3450", "ok", "slave")
        st.addSentinelFields("6.7.8.9", "11234", "sentinel")
@@ -254,7 +254,7 @@ func TestGetAddressSentinelsSuccessfully(t *testing.T) {
 
 func TestGetAddressSentinelsNoIpPort(t *testing.T) {
        st := setupDbState()
-       st.setMasterFields("master", "1.2.3.4", "60000", "2", "master")
+       st.setPrimaryFields("master", "1.2.3.4", "60000", "2", "master")
        st.addReplicaFields("slave", "", "", "ok", "slave")
        st.addReplicaFields("slave", "6.7.8.10", "3450", "ok", "slave")
        st.addSentinelFields("", "", "sentinel")

diff --git a/internal/sdlgoredis/sdlgoredis.go b/internal/sdlgoredis/sdlgoredis.go
index 5f64960..cefe4be 100644 (file)
--- a/internal/sdlgoredis/sdlgoredis.go
+++ b/internal/sdlgoredis/sdlgoredis.go
@@ -497,13 +497,14 @@ func readRedisInfoReplyFields(input []string, info *DbInfo) {
                if idx := strings.Index(line, "role:"); idx != -1 {
                        roleStr := line[idx+len("role:"):]
                        if roleStr == "master" {
-                               info.Fields.MasterRole = true
+                               info.Fields.PrimaryRole = true
                        }
                } else if idx := strings.Index(line, "connected_slaves:"); idx != -1 {
                        cntStr := line[idx+len("connected_slaves:"):]
                        if cnt, err := strconv.ParseUint(cntStr, 10, 32); err == nil {
                                info.Fields.ConnectedReplicaCnt = uint32(cnt)
                        }
+
                }
        }
 }
@@ -531,10 +532,10 @@ func (db *DB) State() (*DbState, error) {
 
 func fillDbStateFromDbInfo(info *DbInfo) DbState {
        var dbState DbState
-       if info.Fields.MasterRole == true {
+       if info.Fields.PrimaryRole == true {
                dbState = DbState{
-                       MasterDbState: MasterDbState{
-                               Fields: MasterDbStateFields{
+                       PrimaryDbState: PrimaryDbState{
+                               Fields: PrimaryDbStateFields{
                                        Role:  "master",
                                        Flags: "master",
                                },

diff --git a/internal/sdlgoredis/sdlgoredis_test.go b/internal/sdlgoredis/sdlgoredis_test.go
index 740674d..16b9c75 100644 (file)
--- a/internal/sdlgoredis/sdlgoredis_test.go
+++ b/internal/sdlgoredis/sdlgoredis_test.go
@@ -1032,7 +1032,7 @@ func TestClientTwoSentinelRedisEnvs(t *testing.T) {
        setupVals.rClient[1].AssertExpectations(t)
 }
 
-func TestInfoOfMasterRedisWithTwoSlavesSuccessfully(t *testing.T) {
+func TestInfoOfPrimaryRedisWithTwoReplicasSuccessfully(t *testing.T) {
        _, r, db := setupHaEnv(true)
        redisInfo := "# Replication\r\n" +
                "role:master\r\n" +
@@ -1042,7 +1042,7 @@ func TestInfoOfMasterRedisWithTwoSlavesSuccessfully(t *testing.T) {
                "slave1:ip=5.6.7.8,port=6379,state=online,offset=100200300,lag=0\r\n"
        expInfo := &sdlgoredis.DbInfo{
                Fields: sdlgoredis.DbInfoFields{
-                       MasterRole:          true,
+                       PrimaryRole:         true,
                        ConnectedReplicaCnt: 2,
                },
        }
@@ -1054,7 +1054,7 @@ func TestInfoOfMasterRedisWithTwoSlavesSuccessfully(t *testing.T) {
        r.AssertExpectations(t)
 }
 
-func TestInfoOfMasterRedisWithOneSlaveOnlineAndOtherSlaveNotOnlineSuccessfully(t *testing.T) {
+func TestInfoOfPrimaryRedisWithOneReplicaOnlineAndOtherReplicaNotOnlineSuccessfully(t *testing.T) {
        _, r, db := setupHaEnv(true)
        redisInfo := "# Replication\r\n" +
                "role:master\r\n" +
@@ -1064,7 +1064,7 @@ func TestInfoOfMasterRedisWithOneSlaveOnlineAndOtherSlaveNotOnlineSuccessfully(t
                "slave1:ip=5.6.7.8,port=6379,state=wait_bgsave,offset=100200300,lag=0\r\n"
        expInfo := &sdlgoredis.DbInfo{
                Fields: sdlgoredis.DbInfoFields{
-                       MasterRole:          true,
+                       PrimaryRole:         true,
                        ConnectedReplicaCnt: 1,
                },
        }
@@ -1076,7 +1076,7 @@ func TestInfoOfMasterRedisWithOneSlaveOnlineAndOtherSlaveNotOnlineSuccessfully(t
        r.AssertExpectations(t)
 }
 
-func TestInfoOfStandaloneMasterRedisSuccessfully(t *testing.T) {
+func TestInfoOfStandalonePrimaryRedisSuccessfully(t *testing.T) {
        _, r, db := setupHaEnv(true)
        redisInfo := "# Replication\r\n" +
                "role:master\r\n" +
@@ -1084,7 +1084,7 @@ func TestInfoOfStandaloneMasterRedisSuccessfully(t *testing.T) {
                "min_slaves_good_slaves:0\r\n"
        expInfo := &sdlgoredis.DbInfo{
                Fields: sdlgoredis.DbInfoFields{
-                       MasterRole:          true,
+                       PrimaryRole:         true,
                        ConnectedReplicaCnt: 0,
                },
        }
@@ -1113,7 +1113,7 @@ func TestInfoWithEmptyContentSuccessfully(t *testing.T) {
        var redisInfo string
        expInfo := &sdlgoredis.DbInfo{
                Fields: sdlgoredis.DbInfoFields{
-                       MasterRole: false,
+                       PrimaryRole: false,
                },
        }
 
@@ -1124,20 +1124,20 @@ func TestInfoWithEmptyContentSuccessfully(t *testing.T) {
        r.AssertExpectations(t)
 }
 
-func TestStateWithMasterAndTwoSlaveRedisSuccessfully(t *testing.T) {
+func TestStateWithPrimaryAndTwoReplicaRedisSuccessfully(t *testing.T) {
        _, r, s, db := setupHaEnvWithSentinels(true)
-       redisMasterState := map[string]string{
+       redisPrimaryState := map[string]string{
                "role-reported": "master",
        }
-       redisSlavesState := make([]interface{}, 2)
-       redisSlavesState[0] = []interface{}{
+       redisReplicasState := make([]interface{}, 2)
+       redisReplicasState[0] = []interface{}{
                "role-reported", "slave",
                "ip", "10.20.30.40",
                "port", "6379",
                "flags", "slave",
                "master-link-status", "up",
        }
-       redisSlavesState[1] = []interface{}{
+       redisReplicasState[1] = []interface{}{
                "master-link-status", "up",
                "ip", "10.20.30.50",
                "flags", "slave",
@@ -1157,8 +1157,8 @@ func TestStateWithMasterAndTwoSlaveRedisSuccessfully(t *testing.T) {
        }
 
        expState := &sdlgoredis.DbState{
-               MasterDbState: sdlgoredis.MasterDbState{
-                       Fields: sdlgoredis.MasterDbStateFields{
+               PrimaryDbState: sdlgoredis.PrimaryDbState{
+                       Fields: sdlgoredis.PrimaryDbStateFields{
                                Role: "master",
                        },
                },
@@ -1166,20 +1166,20 @@ func TestStateWithMasterAndTwoSlaveRedisSuccessfully(t *testing.T) {
                        States: []*sdlgoredis.ReplicaDbState{
                                &sdlgoredis.ReplicaDbState{
                                        Fields: sdlgoredis.ReplicaDbStateFields{
-                                               Role:             "slave",
-                                               Ip:               "10.20.30.40",
-                                               Port:             "6379",
-                                               MasterLinkStatus: "up",
-                                               Flags:            "slave",
+                                               Role:              "slave",
+                                               Ip:                "10.20.30.40",
+                                               Port:              "6379",
+                                               PrimaryLinkStatus: "up",
+                                               Flags:             "slave",
                                        },
                                },
                                &sdlgoredis.ReplicaDbState{
                                        Fields: sdlgoredis.ReplicaDbStateFields{
-                                               Role:             "slave",
-                                               Ip:               "10.20.30.50",
-                                               Port:             "30000",
-                                               MasterLinkStatus: "up",
-                                               Flags:            "slave",
+                                               Role:              "slave",
+                                               Ip:                "10.20.30.50",
+                                               Port:              "30000",
+                                               PrimaryLinkStatus: "up",
+                                               Flags:             "slave",
                                        },
                                },
                        },
@@ -1204,8 +1204,8 @@ func TestStateWithMasterAndTwoSlaveRedisSuccessfully(t *testing.T) {
                },
        }
 
-       s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisMasterState, nil))
-       s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisSlavesState, nil))
+       s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisPrimaryState, nil))
+       s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisReplicasState, nil))
        s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState, nil))
        ret, err := db.State()
        assert.Nil(t, err)
@@ -1213,11 +1213,11 @@ func TestStateWithMasterAndTwoSlaveRedisSuccessfully(t *testing.T) {
        r.AssertExpectations(t)
 }
 
-func TestStateWithMasterAndOneSlaveRedisFailureInMasterRedisCall(t *testing.T) {
+func TestStateWithPrimaryAndOneReplicaRedisFailureInPrimaryRedisCall(t *testing.T) {
        _, r, s, db := setupHaEnvWithSentinels(true)
-       redisMasterState := map[string]string{}
-       redisSlavesState := make([]interface{}, 1)
-       redisSlavesState[0] = []interface{}{
+       redisPrimaryState := map[string]string{}
+       redisReplicasState := make([]interface{}, 1)
+       redisReplicasState[0] = []interface{}{
                "role-reported", "slave",
                "ip", "10.20.30.40",
                "port", "6379",
@@ -1232,18 +1232,18 @@ func TestStateWithMasterAndOneSlaveRedisFailureInMasterRedisCall(t *testing.T) {
        }
 
        expState := &sdlgoredis.DbState{
-               MasterDbState: sdlgoredis.MasterDbState{
+               PrimaryDbState: sdlgoredis.PrimaryDbState{
                        Err: errors.New("Some error"),
                },
                ReplicasDbState: &sdlgoredis.ReplicasDbState{
                        States: []*sdlgoredis.ReplicaDbState{
                                &sdlgoredis.ReplicaDbState{
                                        Fields: sdlgoredis.ReplicaDbStateFields{
-                                               Role:             "slave",
-                                               Ip:               "10.20.30.40",
-                                               Port:             "6379",
-                                               MasterLinkStatus: "up",
-                                               Flags:            "slave",
+                                               Role:              "slave",
+                                               Ip:                "10.20.30.40",
+                                               Port:              "6379",
+                                               PrimaryLinkStatus: "up",
+                                               Flags:             "slave",
                                        },
                                },
                        },
@@ -1261,8 +1261,8 @@ func TestStateWithMasterAndOneSlaveRedisFailureInMasterRedisCall(t *testing.T) {
                },
        }
 
-       s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisMasterState, errors.New("Some error")))
-       s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisSlavesState, nil))
+       s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisPrimaryState, errors.New("Some error")))
+       s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisReplicasState, nil))
        s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState, nil))
        ret, err := db.State()
        assert.NotNil(t, err)
@@ -1270,13 +1270,13 @@ func TestStateWithMasterAndOneSlaveRedisFailureInMasterRedisCall(t *testing.T) {
        r.AssertExpectations(t)
 }
 
-func TestStateWithMasterAndOneSlaveRedisFailureInSlavesRedisCall(t *testing.T) {
+func TestStateWithPrimaryAndOneReplicaRedisFailureInReplicasRedisCall(t *testing.T) {
        _, r, s, db := setupHaEnvWithSentinels(true)
-       redisMasterState := map[string]string{
+       redisPrimaryState := map[string]string{
                "role-reported": "master",
        }
-       redisSlavesState := make([]interface{}, 1)
-       redisSlavesState[0] = []interface{}{}
+       redisReplicasState := make([]interface{}, 1)
+       redisReplicasState[0] = []interface{}{}
        redisSentinelsState := make([]interface{}, 1)
        redisSentinelsState[0] = []interface{}{
                "ip", "10.20.30.40",
@@ -1285,8 +1285,8 @@ func TestStateWithMasterAndOneSlaveRedisFailureInSlavesRedisCall(t *testing.T) {
        }
 
        expState := &sdlgoredis.DbState{
-               MasterDbState: sdlgoredis.MasterDbState{
-                       Fields: sdlgoredis.MasterDbStateFields{
+               PrimaryDbState: sdlgoredis.PrimaryDbState{
+                       Fields: sdlgoredis.PrimaryDbStateFields{
                                Role: "master",
                        },
                },
@@ -1307,8 +1307,8 @@ func TestStateWithMasterAndOneSlaveRedisFailureInSlavesRedisCall(t *testing.T) {
                },
        }
 
-       s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisMasterState, nil))
-       s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisSlavesState, errors.New("Some error")))
+       s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisPrimaryState, nil))
+       s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisReplicasState, errors.New("Some error")))
        s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState, nil))
        ret, err := db.State()
        assert.NotNil(t, err)
@@ -1316,13 +1316,13 @@ func TestStateWithMasterAndOneSlaveRedisFailureInSlavesRedisCall(t *testing.T) {
        r.AssertExpectations(t)
 }
 
-func TestStateWithMasterAndOneSlaveRedisFailureInSentinelsRedisCall(t *testing.T) {
+func TestStateWithPrimaryAndOneReplicaRedisFailureInSentinelsRedisCall(t *testing.T) {
        _, r, s, db := setupHaEnvWithSentinels(true)
-       redisMasterState := map[string]string{
+       redisPrimaryState := map[string]string{
                "role-reported": "master",
        }
-       redisSlavesState := make([]interface{}, 1)
-       redisSlavesState[0] = []interface{}{
+       redisReplicasState := make([]interface{}, 1)
+       redisReplicasState[0] = []interface{}{
                "role-reported", "slave",
                "ip", "10.20.30.40",
                "port", "6379",
@@ -1337,8 +1337,8 @@ func TestStateWithMasterAndOneSlaveRedisFailureInSentinelsRedisCall(t *testing.T
        }
 
        expState := &sdlgoredis.DbState{
-               MasterDbState: sdlgoredis.MasterDbState{
-                       Fields: sdlgoredis.MasterDbStateFields{
+               PrimaryDbState: sdlgoredis.PrimaryDbState{
+                       Fields: sdlgoredis.PrimaryDbStateFields{
                                Role: "master",
                        },
                },
@@ -1346,11 +1346,11 @@ func TestStateWithMasterAndOneSlaveRedisFailureInSentinelsRedisCall(t *testing.T
                        States: []*sdlgoredis.ReplicaDbState{
                                &sdlgoredis.ReplicaDbState{
                                        Fields: sdlgoredis.ReplicaDbStateFields{
-                                               Role:             "slave",
-                                               Ip:               "10.20.30.40",
-                                               Port:             "6379",
-                                               MasterLinkStatus: "up",
-                                               Flags:            "slave",
+                                               Role:              "slave",
+                                               Ip:                "10.20.30.40",
+                                               Port:              "6379",
+                                               PrimaryLinkStatus: "up",
+                                               Flags:             "slave",
                                        },
                                },
                        },
@@ -1361,8 +1361,8 @@ func TestStateWithMasterAndOneSlaveRedisFailureInSentinelsRedisCall(t *testing.T
                },
        }
 
-       s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisMasterState, nil))
-       s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisSlavesState, nil))
+       s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisPrimaryState, nil))
+       s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisReplicasState, nil))
        s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState, errors.New("Some error")))
        ret, err := db.State()
        assert.NotNil(t, err)
@@ -1370,7 +1370,7 @@ func TestStateWithMasterAndOneSlaveRedisFailureInSentinelsRedisCall(t *testing.T
        r.AssertExpectations(t)
 }
 
-func TestStateWithSingleMasterRedisSuccessfully(t *testing.T) {
+func TestStateWithSinglePrimaryRedisSuccessfully(t *testing.T) {
        _, r, db := setupSingleEnv(true)
        redisInfo := "# Replication\r\n" +
                "role:master\r\n" +
@@ -1378,8 +1378,8 @@ func TestStateWithSingleMasterRedisSuccessfully(t *testing.T) {
                "min_slaves_good_slaves:0\r\n"
 
        expState := &sdlgoredis.DbState{
-               MasterDbState: sdlgoredis.MasterDbState{
-                       Fields: sdlgoredis.MasterDbStateFields{
+               PrimaryDbState: sdlgoredis.PrimaryDbState{
+                       Fields: sdlgoredis.PrimaryDbStateFields{
                                Role:  "master",
                                Flags: "master",
                        },
@@ -1393,7 +1393,7 @@ func TestStateWithSingleMasterRedisSuccessfully(t *testing.T) {
        r.AssertExpectations(t)
 }
 
-func TestStateWithSingleMasterRedisFailureInInfoCall(t *testing.T) {
+func TestStateWithSinglePrimaryRedisFailureInInfoCall(t *testing.T) {
        _, r, db := setupSingleEnv(true)
        redisInfo := ""
        expState := &sdlgoredis.DbState{}

diff --git a/internal/sdlgoredis/sdlgosentinel.go b/internal/sdlgoredis/sdlgosentinel.go
index 014d4ba..f439570 100644 (file)
--- a/internal/sdlgoredis/sdlgosentinel.go
+++ b/internal/sdlgoredis/sdlgosentinel.go
@@ -55,14 +55,14 @@ func newRedisSentinel(cfg *Config, addr string) *Sentinel {
 
 func (s *Sentinel) GetDbState() (*DbState, error) {
        state := new(DbState)
-       mState, mErr := s.getMasterDbState()
+       pState, pErr := s.getPrimaryDbState()
        rState, rErr := s.getReplicasState()
        sState, sErr := s.getSentinelsState()
-       state.MasterDbState = *mState
+       state.PrimaryDbState = *pState
        state.ReplicasDbState = rState
        state.SentinelsDbState = sState
-       if mErr != nil {
-               return state, mErr
+       if pErr != nil {
+               return state, pErr
        }
        if rErr != nil {
                return state, rErr
@@ -70,8 +70,8 @@ func (s *Sentinel) GetDbState() (*DbState, error) {
        return state, sErr
 }
 
-func (s *Sentinel) getMasterDbState() (*MasterDbState, error) {
-       state := new(MasterDbState)
+func (s *Sentinel) getPrimaryDbState() (*PrimaryDbState, error) {
+       state := new(PrimaryDbState)
        redisVal, redisErr := s.Master(s.Cfg.masterName).Result()
        if redisErr == nil {
                state.Fields.Ip = redisVal["ip"]
@@ -89,8 +89,8 @@ func (s *Sentinel) getReplicasState() (*ReplicasDbState, error) {
 
        redisVal, redisErr := s.Slaves(s.Cfg.masterName).Result()
        if redisErr == nil {
-               for _, redisSlave := range redisVal {
-                       replicaState := readReplicaState(redisSlave.([]interface{}))
+               for _, redisReplica := range redisVal {
+                       replicaState := readReplicaState(redisReplica.([]interface{}))
                        states.States = append(states.States, replicaState)
                }
        }
@@ -98,19 +98,19 @@ func (s *Sentinel) getReplicasState() (*ReplicasDbState, error) {
        return states, redisErr
 }
 
-func readReplicaState(redisSlaves []interface{}) *ReplicaDbState {
+func readReplicaState(redisReplicas []interface{}) *ReplicaDbState {
        state := new(ReplicaDbState)
-       for i := 0; i < len(redisSlaves); i += 2 {
-               if redisSlaves[i].(string) == "ip" {
-                       state.Fields.Ip = redisSlaves[i+1].(string)
-               } else if redisSlaves[i].(string) == "port" {
-                       state.Fields.Port = redisSlaves[i+1].(string)
-               } else if redisSlaves[i].(string) == "flags" {
-                       state.Fields.Flags = redisSlaves[i+1].(string)
-               } else if redisSlaves[i].(string) == "role-reported" {
-                       state.Fields.Role = redisSlaves[i+1].(string)
-               } else if redisSlaves[i].(string) == "master-link-status" {
-                       state.Fields.MasterLinkStatus = redisSlaves[i+1].(string)
+       for i := 0; i < len(redisReplicas); i += 2 {
+               if redisReplicas[i].(string) == "ip" {
+                       state.Fields.Ip = redisReplicas[i+1].(string)
+               } else if redisReplicas[i].(string) == "port" {
+                       state.Fields.Port = redisReplicas[i+1].(string)
+               } else if redisReplicas[i].(string) == "flags" {
+                       state.Fields.Flags = redisReplicas[i+1].(string)
+               } else if redisReplicas[i].(string) == "role-reported" {
+                       state.Fields.Role = redisReplicas[i+1].(string)
+               } else if redisReplicas[i].(string) == "master-link-status" {
+                       state.Fields.PrimaryLinkStatus = redisReplicas[i+1].(string)
                }
        }
        return state