wal-g

1
package functests
2

3
import (
4
	"fmt"
5
	"time"
6

7
	"github.com/cucumber/godog"
8
	"github.com/pkg/errors"
9
	"github.com/wal-g/tracelog"
10
	"github.com/wal-g/wal-g/tests_func/helpers"
11
	"github.com/wal-g/wal-g/tests_func/utils"
12
)
13

14
func SetupRedisSteps(ctx *godog.ScenarioContext, tctx *TestContext) {
15
	ctx.Step(`^a working redis on ([^\s]*)$`, tctx.isWorkingRedis)
16
	ctx.Step(`^([^\s]*) has test redis data test(\d+)$`, tctx.redisHasTestRedisDataTest)
17
	ctx.Step(`^we create ([^\s]*) redis-backup$`, tctx.createRedisBackup)
18
	ctx.Step(`^we delete redis backups retain (\d+) via ([^\s]*)$`, tctx.weDeleteRedisBackupsRetainViaRedis)
19
	ctx.Step(`^we restart redis-server at ([^\s]*)$`, tctx.weRestartRedisServerAt)
20
	ctx.Step(`^we got same redis data at ([^\s]*) ([^\s]*)$`, tctx.testEqualRedisDataAtHosts)
21
}
22

23
func (tctx *TestContext) isWorkingRedis(hostName string) error {
24
	redisCtl, err := GetRedisCtlFromTestContext(tctx, hostName)
25
	if err != nil {
26
		return err
27
	}
28

29
	return helpers.Retry(tctx.Context, MAX_RETRIES_COUNT, func() error {
30
		tracelog.DebugLogger.Printf("Redis client connect to host '%s'", redisCtl.Addr())
31

32
		status := redisCtl.Ping()
33
		err = status.Err()
34
		if err != nil {
35
			return fmt.Errorf("Client on ping returned err: %v\n", err)
36
		}
37
		if status.Val() != "PONG" {
38
			return fmt.Errorf("Client on ping does not returned PONG: %v\n", err)
39
		}
40
		tracelog.DebugLogger.Printf("Redis: Got PONG on PING from %s", hostName)
41
		return nil
42
	})
43
}
44

45
func (tctx *TestContext) redisHasTestRedisDataTest(host string, testId int) error {
46
	rc, err := GetRedisCtlFromTestContext(tctx, host)
47
	if err != nil {
48
		return err
49
	}
50

51
	docsCount := 10
52
	err = rc.WriteTestData(fmt.Sprintf("test%02d", testId), docsCount)
53
	if err != nil {
54
		return err
55
	}
56
	return nil
57
}
58

59
func (tctx *TestContext) createRedisBackup(host string) error {
60
	rc, err := GetRedisCtlFromTestContext(tctx, host)
61
	if err != nil {
62
		return nil
63
	}
64

65
	beforeBackupTime, err := helpers.TimeInContainer(tctx.Context, rc.Host())
66
	if err != nil {
67
		return err
68
	}
69

70
	passed := beforeBackupTime.Sub(tctx.PreviousBackupTime)
71
	if passed < time.Second {
72
		cmd := []string{"sleep", "1"}
73
		if _, err := helpers.RunCommandStrict(tctx.Context, host, cmd); err != nil {
74
			return err
75
		}
76
	}
77

78
	tracelog.DebugLogger.Println("Push redis backup")
79
	backupId, err := rc.PushBackup()
80
	if err != nil {
81
		return err
82
	}
83
	time.Sleep(1 * time.Second)
84
	tracelog.DebugLogger.Println("Backup created: ", backupId)
85
	return nil
86
}
87

88
func (tctx *TestContext) weDeleteRedisBackupsRetainViaRedis(backupsRetain int, host string) error {
89
	rc, err := GetRedisCtlFromTestContext(tctx, host)
90
	if err != nil {
91
		return err
92
	}
93

94
	return rc.PurgeRetain(backupsRetain)
95
}
96

97
func (tctx *TestContext) weRestartRedisServerAt(host string) error {
98
	rc, err := GetRedisCtlFromTestContext(tctx, host)
99
	if err != nil {
100
		return err
101
	}
102
	cmd := rc.ShutdownNoSave()
103
	if cmd.Err() != nil {
104
		return cmd.Err()
105
	}
106
	return nil
107
}
108

109
func (tctx *TestContext) testEqualRedisDataAtHosts(host1, host2 string) error {
110
	rc1, err := GetRedisCtlFromTestContext(tctx, host1)
111
	if err != nil {
112
		return err
113
	}
114

115
	rc2, err := GetRedisCtlFromTestContext(tctx, host2)
116
	if err != nil {
117
		return err
118
	}
119

120
	dbsize1 := rc1.DBSize()
121
	if dbsize1.Err() != nil {
122
		return errors.Wrapf(dbsize1.Err(), "Host %s doesn't return 'dbsize'", host1)
123
	}
124
	dbsize2 := rc2.DBSize()
125
	if dbsize2.Err() != nil {
126
		return errors.Wrapf(dbsize1.Err(), "Host %s doesn't return 'dbsize'", host2)
127
	}
128
	if dbsize1.Val() != dbsize2.Val() {
129
		return fmt.Errorf("hosts %s and %s have not equal keys count %d != %d", host1, host2, dbsize1.Val(), dbsize2.Val())
130
	}
131

132
	keys1 := rc1.Keys("*")
133
	if keys1.Err() != nil {
134
		return keys1.Err()
135
	}
136

137
	keys2 := rc2.Keys("*")
138
	if keys2.Err() != nil {
139
		return keys2.Err()
140
	}
141

142
	if len(keys1.Val()) == 0 || len(keys2.Val()) == 0 {
143
		return fmt.Errorf("keys1 or keys2 is empty - broken backup")
144
	}
145

146
	if !utils.IsArraysEqual(keys1.Val(), keys2.Val()) {
147
		return fmt.Errorf("keys from redis1/redis2 aren't equal")
148
	}
149
	values1 := rc1.MGet(keys1.Val()...)
150
	values2 := rc1.MGet(keys2.Val()...)
151
	vals1 := make([]string, len(values1.Val()))
152
	vals2 := make([]string, len(values1.Val()))
153

154
	for i, val := range values1.Val() {
155
		vals1[i] = val.(string)
156
	}
157

158
	for i, val := range values2.Val() {
159
		vals2[i] = val.(string)
160
	}
161
	if !utils.IsArraysEqual(vals1, vals2) {
162
		return fmt.Errorf("values from redis1/redis2 aren't equal")
163
	}
164
	return nil
165
}
166