cubefs

1
// Copyright 2022 The CubeFS Authors.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//     http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
12
// implied. See the License for the specific language governing
13
// permissions and limitations under the License.
14

15
package access
16

17
import (
18
	"fmt"
19
	"hash/crc32"
20
	"math"
21
	"testing"
22

23
	"github.com/stretchr/testify/require"
24

25
	"github.com/cubefs/cubefs/blobstore/api/access"
26
	"github.com/cubefs/cubefs/blobstore/common/codemode"
27
	"github.com/cubefs/cubefs/blobstore/common/proto"
28
	"github.com/cubefs/cubefs/blobstore/util/bytespool"
29
)
30

31
var (
32
	testMaxBlob = access.SliceInfo{
33
		MinBid: proto.BlobID(math.MaxUint64),
34
		Vid:    proto.Vid(math.MaxInt32),
35
		Count:  math.MaxUint32,
36
	}
37
	testMaxLoc = access.Location{
38
		ClusterID: proto.ClusterID(math.MaxUint32),
39
		CodeMode:  codemode.CodeMode(math.MaxInt8),
40
		Size:      math.MaxUint64,
41
		BlobSize:  math.MaxUint32,
42
		Crc:       math.MaxUint32,
43
	}
44

45
	testMinBlob = access.SliceInfo{}
46
	testMinLoc  = access.Location{}
47
)
48

49
func TestAccessServiceLocationCrc(t *testing.T) {
50
	{
51
		_, err := calcCrc(nil)
52
		require.Error(t, err)
53
	}
54
	{
55
		crc, err := calcCrc(&testMinLoc)
56
		require.NoError(t, err)
57
		require.Equal(t, uint32(0x8a7370cc), crc)
58
	}
59
	{
60
		crc, err := calcCrc(&testMaxLoc)
61
		require.NoError(t, err)
62
		require.Equal(t, uint32(0xda55150a), crc)
63
	}
64
	{
65
		loc := testMinLoc.Copy()
66
		loc.Size = 1 << 30
67

68
		err := fillCrc(&loc)
69
		require.NoError(t, err)
70
		require.Equal(t, uint32(0x9e17bc9e), loc.Crc)
71
	}
72
	{
73
		loc := testMinLoc.Copy()
74
		loc.Size = 1 << 30
75
		require.False(t, verifyCrc(&loc))
76

77
		loc.Crc = 0x9e17bc9e
78
		require.True(t, verifyCrc(&loc))
79
	}
80
}
81

82
func TestAccessServiceLocationSecret(t *testing.T) {
83
	secret := make([]byte, len(_crcMagicKey))
84
	copy(secret, _crcMagicKey[:])
85
	defer func() {
86
		copy(_crcMagicKey[:], secret)
87
	}()
88
	{
89
		initLocationSecret([]byte{0x34, 0x45, 0x18, 0x4f})
90
		crc, err := calcCrc(&testMinLoc)
91
		require.NoError(t, err)
92
		require.NotEqual(t, uint32(0x8a7370cc), crc)
93
		require.Equal(t, uint32(0xdbe8df90), crc)
94
	}
95
	{
96
		// init once
97
		initLocationSecret([]byte{0x1, 0x2, 0x3, 0x4})
98
		crc, err := calcCrc(&testMinLoc)
99
		require.NoError(t, err)
100
		require.Equal(t, uint32(0xdbe8df90), crc)
101
	}
102
}
103

104
func TestAccessServiceLocationSignCrc(t *testing.T) {
105
	loc := &access.Location{
106
		ClusterID: 1,
107
		CodeMode:  1,
108
		Size:      1023,
109
		BlobSize:  6,
110
		Crc:       0,
111
		Blobs: []access.SliceInfo{{
112
			MinBid: 11,
113
			Vid:    199,
114
			Count:  10,
115
		}},
116
	}
117
	fillCrc(loc)
118
	require.True(t, verifyCrc(loc))
119

120
	{
121
		loc1, loc2 := loc.Copy(), loc.Copy()
122
		require.NoError(t, signCrc(loc, []access.Location{loc1, loc2}))
123
	}
124
	{
125
		loc1, loc2 := loc.Copy(), loc.Copy()
126
		loc1.BlobSize = 100
127
		fillCrc(&loc1)
128
		require.Error(t, signCrc(loc, []access.Location{loc1, loc2}))
129
	}
130
	{
131
		loc1, loc2 := loc.Copy(), loc.Copy()
132
		loc2.Crc = 0
133
		require.Error(t, signCrc(loc, []access.Location{loc1, loc2}))
134
	}
135
	{
136
		loc1, loc2 := loc.Copy(), loc.Copy()
137
		loc2.ClusterID = 2
138
		fillCrc(&loc2)
139
		require.Error(t, signCrc(loc, []access.Location{loc1, loc2}))
140
	}
141
	{
142
		loc1, loc2 := loc.Copy(), loc.Copy()
143
		loc2.CodeMode = 100
144
		fillCrc(&loc2)
145
		require.Error(t, signCrc(loc, []access.Location{loc1, loc2}))
146
	}
147
	{
148
		loc1, loc2 := loc.Copy(), loc.Copy()
149
		loc1.Blobs = nil
150
		loc2.Blobs[0].Count = 5
151
		fillCrc(&loc1)
152
		fillCrc(&loc2)
153
		require.Error(t, signCrc(loc, []access.Location{loc1, loc2}))
154
	}
155
}
156

157
func calcCrcWithoutMagic(loc *access.Location) (uint32, error) {
158
	crcWriter := crc32.New(_crcTable)
159

160
	buf := bytespool.Alloc(1024)
161
	defer bytespool.Free(buf)
162

163
	n := loc.Encode2(buf)
164
	crcWriter.Write(buf[4:n])
165

166
	return crcWriter.Sum32(), nil
167
}
168

169
func benchmarkCrc(b *testing.B, key string,
170
	location access.Location, blob access.SliceInfo,
171
	run func(loc *access.Location) (uint32, error)) {
172
	cases := []int{0, 2, 4, 8, 16, 32}
173
	for _, l := range cases {
174
		b.ResetTimer()
175
		b.Run(fmt.Sprintf(key+"-%d", l), func(b *testing.B) {
176
			loc := location.Copy()
177
			loc.Blobs = make([]access.SliceInfo, l)
178
			for idx := range loc.Blobs {
179
				loc.Blobs[idx] = blob
180
			}
181
			b.ResetTimer()
182
			for ii := 0; ii <= b.N; ii++ {
183
				run(&loc)
184
			}
185
		})
186
	}
187
}
188

189
func BenchmarkAccessServerCrcWithMagicMin(b *testing.B) {
190
	benchmarkCrc(b, "min-with-magic", testMinLoc, testMinBlob, calcCrc)
191
}
192

193
func BenchmarkAccessServerCrcWithoutMagicMin(b *testing.B) {
194
	benchmarkCrc(b, "min-without-magic", testMinLoc, testMinBlob, calcCrcWithoutMagic)
195
}
196

197
func BenchmarkAccessServerCrcWithMagicMax(b *testing.B) {
198
	benchmarkCrc(b, "max-with-magic", testMaxLoc, testMaxBlob, calcCrc)
199
}
200

201
func BenchmarkAccessServerCrcWithoutMagicMax(b *testing.B) {
202
	benchmarkCrc(b, "max-without-magic", testMaxLoc, testMaxBlob, calcCrcWithoutMagic)
203
}
204