From ee834c59a83cdd10889b3439a281fe43b9f98839 Mon Sep 17 00:00:00 2001 From: Timo Tietavainen Date: Sun, 28 Nov 2021 11:02:07 +0200 Subject: [PATCH] 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 Change-Id: I3ecdcab4d8d36a6b8311fa34316d8ddbf71ae5a4 --- internal/cli/healthcheck.go | 15 ++-- internal/cli/healthcheck_test.go | 42 +++++------ internal/cli/namespaces.go | 2 +- internal/cli/namespaces_test.go | 6 +- internal/sdlgoredis/dbinfo.go | 2 +- internal/sdlgoredis/dbstate.go | 54 +++++++------- internal/sdlgoredis/dbstate_test.go | 88 +++++++++++------------ internal/sdlgoredis/sdlgoredis.go | 9 +-- internal/sdlgoredis/sdlgoredis_test.go | 126 ++++++++++++++++----------------- internal/sdlgoredis/sdlgosentinel.go | 40 +++++------ 10 files changed, 194 insertions(+), 190 deletions(-) diff --git a/internal/cli/healthcheck.go b/internal/cli/healthcheck.go index de78ba9..2ede93e 100644 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 -- 2.16.6