Skip to content

Commit 89a9a53

Browse files
tipabutipabu
committed
Make gometalinter happier
Still *lots* of room for improvement.
1 parent 4f5278c commit 89a9a53

File tree

7 files changed

+105
-103
lines changed

7 files changed

+105
-103
lines changed

‎backend.go

+59-65
Original file line numberDiff line numberDiff line change
@@ -5,12 +5,15 @@ package erasurecode
55
#include <stdlib.h>
66
#include <liberasurecode/erasurecode.h>
77
#include <liberasurecode/erasurecode_helpers_ext.h>
8-
// shim to make dereferencing frags easier
9-
void * strArrayItem(char ** arr, int idx) { return arr[idx]; }
8+
// shims to make working with frag arrays easier
9+
char ** makeStrArray(int n) { return calloc(n, sizeof (char *)); }
10+
void freeStrArray(char ** arr) { free(arr); }
11+
void * getStrArrayItem(char ** arr, int idx) { return arr[idx]; }
12+
void setStrArrayItem(char ** arr, int idx, unsigned char * val) { arr[idx] = (char *) val; }
1013
// shims because the fragment headers use misaligned fields
1114
uint64_t getOrigDataSize(struct fragment_header_s *header) { return header->meta.orig_data_size; }
1215
uint32_t getBackendVersion(struct fragment_header_s *header) { return header->meta.backend_version; }
13-
ec_backend_id_t getBackendId(struct fragment_header_s *header) { return header->meta.backend_id; }
16+
ec_backend_id_t getBackendID(struct fragment_header_s *header) { return header->meta.backend_id; }
1417
uint32_t getECVersion(struct fragment_header_s *header) { return header->libec_version; }
1518
*/
1619
import "C"
@@ -74,30 +77,30 @@ func AvailableBackends() (avail []string) {
7477
return
7578
}
7679

77-
type ErasureCodeParams struct {
80+
type Params struct {
7881
Name string
7982
K int
8083
M int
8184
W int
8285
HD int
8386
}
8487

85-
type ErasureCodeBackend struct {
86-
ErasureCodeParams
87-
libec_desc C.int
88+
type Backend struct {
89+
Params
90+
libecDesc C.int
8891
}
8992

9093
func BackendIsAvailable(name string) bool {
91-
id, err := nameToId(name)
94+
id, err := nameToID(name)
9295
if err != nil {
9396
return false
9497
}
9598
return C.liberasurecode_backend_available(id) != 0
9699
}
97100

98-
func InitBackend(params ErasureCodeParams) (ErasureCodeBackend, error) {
99-
backend := ErasureCodeBackend{params, 0}
100-
id, err := nameToId(backend.Name)
101+
func InitBackend(params Params) (Backend, error) {
102+
backend := Backend{params, 0}
103+
id, err := nameToID(backend.Name)
101104
if err != nil {
102105
return backend, err
103106
}
@@ -109,110 +112,101 @@ func InitBackend(params ErasureCodeParams) (ErasureCodeBackend, error) {
109112
ct: C.CHKSUM_CRC32,
110113
})
111114
if desc < 0 {
112-
return backend, errors.New(fmt.Sprintf(
113-
"instance_create() returned %v", errToName(-desc)))
115+
return backend, fmt.Errorf("instance_create() returned %v", errToName(-desc))
114116
}
115-
backend.libec_desc = desc
117+
backend.libecDesc = desc
116118
return backend, nil
117119
}
118120

119-
func (backend *ErasureCodeBackend) Close() error {
120-
if backend.libec_desc == 0 {
121+
func (backend *Backend) Close() error {
122+
if backend.libecDesc == 0 {
121123
return errors.New("backend already closed")
122124
}
123-
if rc := C.liberasurecode_instance_destroy(backend.libec_desc); rc != 0 {
124-
return errors.New(fmt.Sprintf(
125-
"instance_destroy() returned %v", errToName(-rc)))
125+
if rc := C.liberasurecode_instance_destroy(backend.libecDesc); rc != 0 {
126+
return fmt.Errorf("instance_destroy() returned %v", errToName(-rc))
126127
}
127-
backend.libec_desc = 0
128+
backend.libecDesc = 0
128129
return nil
129130
}
130131

131-
func (backend *ErasureCodeBackend) Encode(data []byte) ([][]byte, error) {
132-
var data_frags **C.char
133-
var parity_frags **C.char
134-
var frag_len C.uint64_t
135-
p_data := (*C.char)(unsafe.Pointer(&data[0]))
132+
func (backend *Backend) Encode(data []byte) ([][]byte, error) {
133+
var dataFrags **C.char
134+
var parityFrags **C.char
135+
var fragLength C.uint64_t
136+
pData := (*C.char)(unsafe.Pointer(&data[0]))
136137
if rc := C.liberasurecode_encode(
137-
backend.libec_desc, p_data, C.uint64_t(len(data)),
138-
&data_frags, &parity_frags, &frag_len); rc != 0 {
139-
return nil, errors.New(fmt.Sprintf(
140-
"encode() returned %v", errToName(-rc)))
138+
backend.libecDesc, pData, C.uint64_t(len(data)),
139+
&dataFrags, &parityFrags, &fragLength); rc != 0 {
140+
return nil, fmt.Errorf("encode() returned %v", errToName(-rc))
141141
}
142142
defer C.liberasurecode_encode_cleanup(
143-
backend.libec_desc, data_frags, parity_frags)
143+
backend.libecDesc, dataFrags, parityFrags)
144144
result := make([][]byte, backend.K+backend.M)
145145
for i := 0; i < backend.K; i++ {
146-
result[i] = C.GoBytes(C.strArrayItem(data_frags, C.int(i)), C.int(frag_len))
146+
result[i] = C.GoBytes(C.getStrArrayItem(dataFrags, C.int(i)), C.int(fragLength))
147147
}
148148
for i := 0; i < backend.M; i++ {
149-
result[i+backend.K] = C.GoBytes(C.strArrayItem(parity_frags, C.int(i)), C.int(frag_len))
149+
result[i+backend.K] = C.GoBytes(C.getStrArrayItem(parityFrags, C.int(i)), C.int(fragLength))
150150
}
151151
return result, nil
152152
}
153153

154-
func (backend *ErasureCodeBackend) Decode(frags [][]byte) ([]byte, error) {
154+
func (backend *Backend) Decode(frags [][]byte) ([]byte, error) {
155155
var data *C.char
156-
var data_len C.uint64_t
156+
var dataLength C.uint64_t
157157
if len(frags) == 0 {
158158
return nil, errors.New("decoding requires at least one fragment")
159159
}
160160

161-
c_frags := (**C.char)(C.calloc(C.size_t(len(frags)), C.size_t(int(unsafe.Sizeof(data)))))
162-
defer C.free(unsafe.Pointer(c_frags))
163-
base := uintptr(unsafe.Pointer(c_frags))
161+
cFrags := C.makeStrArray(C.int(len(frags)))
162+
defer C.freeStrArray(cFrags)
164163
for index, frag := range frags {
165-
ptr := (**C.char)(unsafe.Pointer(base + uintptr(index)*unsafe.Sizeof(*c_frags)))
166-
*ptr = (*C.char)(unsafe.Pointer(&frag[0]))
164+
C.setStrArrayItem(cFrags, C.int(index), (*C.uchar)(&frag[0]))
167165
}
168166

169167
if rc := C.liberasurecode_decode(
170-
backend.libec_desc, c_frags, C.int(len(frags)),
168+
backend.libecDesc, cFrags, C.int(len(frags)),
171169
C.uint64_t(len(frags[0])), C.int(1),
172-
&data, &data_len); rc != 0 {
173-
return nil, errors.New(fmt.Sprintf(
174-
"decode() returned %v", errToName(-rc)))
170+
&data, &dataLength); rc != 0 {
171+
return nil, fmt.Errorf("decode() returned %v", errToName(-rc))
175172
}
176-
defer C.liberasurecode_decode_cleanup(backend.libec_desc, data)
177-
return C.GoBytes(unsafe.Pointer(data), C.int(data_len)), nil
173+
defer C.liberasurecode_decode_cleanup(backend.libecDesc, data)
174+
return C.GoBytes(unsafe.Pointer(data), C.int(dataLength)), nil
178175
}
179176

180-
func (backend *ErasureCodeBackend) Reconstruct(frags [][]byte, frag_index int) ([]byte, error) {
177+
func (backend *Backend) Reconstruct(frags [][]byte, fragIndex int) ([]byte, error) {
181178
if len(frags) == 0 {
182179
return nil, errors.New("reconstruction requires at least one fragment")
183180
}
184-
frag_len := len(frags[0])
185-
data := make([]byte, frag_len)
186-
p_data := (*C.char)(unsafe.Pointer(&data[0]))
181+
fragLength := len(frags[0])
182+
data := make([]byte, fragLength)
183+
pData := (*C.char)(unsafe.Pointer(&data[0]))
187184

188-
c_frags := (**C.char)(C.calloc(C.size_t(len(frags)), C.size_t(int(unsafe.Sizeof(p_data)))))
189-
defer C.free(unsafe.Pointer(c_frags))
190-
base := uintptr(unsafe.Pointer(c_frags))
185+
cFrags := C.makeStrArray(C.int(len(frags)))
186+
defer C.freeStrArray(cFrags)
191187
for index, frag := range frags {
192-
ptr := (**C.char)(unsafe.Pointer(base + uintptr(index)*unsafe.Sizeof(*c_frags)))
193-
*ptr = (*C.char)(unsafe.Pointer(&frag[0]))
188+
C.setStrArrayItem(cFrags, C.int(index), (*C.uchar)(&frag[0]))
194189
}
195190

196191
if rc := C.liberasurecode_reconstruct_fragment(
197-
backend.libec_desc, c_frags, C.int(len(frags)),
198-
C.uint64_t(len(frags[0])), C.int(frag_index), p_data); rc != 0 {
199-
return nil, errors.New(fmt.Sprintf(
200-
"reconstruct_fragment() returned %v", errToName(-rc)))
192+
backend.libecDesc, cFrags, C.int(len(frags)),
193+
C.uint64_t(len(frags[0])), C.int(fragIndex), pData); rc != 0 {
194+
return nil, fmt.Errorf("reconstruct_fragment() returned %v", errToName(-rc))
201195
}
202196
return data, nil
203197
}
204198

205-
func (backend *ErasureCodeBackend) IsInvalidFragment(frag []byte) bool {
206-
p_data := (*C.char)(unsafe.Pointer(&frag[0]))
207-
return 1 == C.is_invalid_fragment(backend.libec_desc, p_data)
199+
func (backend *Backend) IsInvalidFragment(frag []byte) bool {
200+
pData := (*C.char)(unsafe.Pointer(&frag[0]))
201+
return 1 == C.is_invalid_fragment(backend.libecDesc, pData)
208202
}
209203

210204
type FragmentInfo struct {
211205
Index int
212206
Size int
213207
BackendMetadataSize int
214208
OrigDataSize uint64
215-
BackendId C.ec_backend_id_t
209+
BackendID C.ec_backend_id_t
216210
BackendName string
217211
BackendVersion Version
218212
ErasureCodeVersion Version
@@ -221,14 +215,14 @@ type FragmentInfo struct {
221215

222216
func GetFragmentInfo(frag []byte) FragmentInfo {
223217
header := *(*C.struct_fragment_header_s)(unsafe.Pointer(&frag[0]))
224-
backendId := C.getBackendId(&header)
218+
backendID := C.getBackendID(&header)
225219
return FragmentInfo{
226220
Index: int(header.meta.idx),
227221
Size: int(header.meta.size),
228222
BackendMetadataSize: int(header.meta.frag_backend_metadata_size),
229223
OrigDataSize: uint64(C.getOrigDataSize(&header)),
230-
BackendId: backendId,
231-
BackendName: idToName(backendId),
224+
BackendID: backendID,
225+
BackendName: idToName(backendID),
232226
BackendVersion: makeVersion(C.getBackendVersion(&header)),
233227
ErasureCodeVersion: makeVersion(C.getECVersion(&header)),
234228
IsValid: C.is_invalid_fragment_header((*C.fragment_header_t)(&header)) == 0,

‎backend_test.go

+26-26
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ import "bytes"
44
import "math/rand"
55
import "testing"
66

7-
var validParams = []ErasureCodeParams{
7+
var validParams = []Params{
88
{Name: "liberasurecode_rs_vand", K: 2, M: 1},
99
{Name: "liberasurecode_rs_vand", K: 10, M: 4},
1010
{Name: "liberasurecode_rs_vand", K: 4, M: 3},
@@ -78,8 +78,8 @@ func TestInitBackend(t *testing.T) {
7878
t.Errorf("%q", err)
7979
continue
8080
}
81-
if backend.libec_desc <= 0 {
82-
t.Errorf("Expected backend descriptor > 0, got %d", backend.libec_desc)
81+
if backend.libecDesc <= 0 {
82+
t.Errorf("Expected backend descriptor > 0, got %d", backend.libecDesc)
8383
}
8484

8585
if err = backend.Close(); err != nil {
@@ -93,38 +93,38 @@ func TestInitBackend(t *testing.T) {
9393

9494
func TestInitBackendFailure(t *testing.T) {
9595
cases := []struct {
96-
params ErasureCodeParams
96+
params Params
9797
want string
9898
}{
99-
{ErasureCodeParams{Name: "liberasurecode_rs_vand", K: -1, M: 1},
99+
{Params{Name: "liberasurecode_rs_vand", K: -1, M: 1},
100100
"instance_create() returned EINVALIDPARAMS"},
101-
{ErasureCodeParams{Name: "liberasurecode_rs_vand", K: 10, M: -1},
101+
{Params{Name: "liberasurecode_rs_vand", K: 10, M: -1},
102102
"instance_create() returned EINVALIDPARAMS"},
103-
{ErasureCodeParams{Name: "non-existent-backend", K: 10, M: 4},
103+
{Params{Name: "non-existent-backend", K: 10, M: 4},
104104
"unsupported backend \"non-existent-backend\""},
105-
{ErasureCodeParams{Name: "", K: 10, M: 4},
105+
{Params{Name: "", K: 10, M: 4},
106106
"unsupported backend \"\""},
107-
{ErasureCodeParams{Name: "liberasurecode_rs_vand", K: 20, M: 20},
107+
{Params{Name: "liberasurecode_rs_vand", K: 20, M: 20},
108108
"instance_create() returned EINVALIDPARAMS"},
109-
{ErasureCodeParams{Name: "flat_xor_hd", K: 4, M: 4, HD: 3},
109+
{Params{Name: "flat_xor_hd", K: 4, M: 4, HD: 3},
110110
"instance_create() returned EBACKENDINITERR"},
111111
}
112112
for _, args := range cases {
113113
backend, err := InitBackend(args.params)
114114
if err == nil {
115115
t.Errorf("Expected error when calling InitBackend(%v)",
116116
args.params)
117-
backend.Close()
117+
_ = backend.Close()
118118
continue
119119
}
120120
if err.Error() != args.want {
121121
t.Errorf("InitBackend(%v) produced error %q, want %q",
122122
args.params, err, args.want)
123123
}
124-
if backend.libec_desc != 0 {
124+
if backend.libecDesc != 0 {
125125
t.Errorf("InitBackend(%v) produced backend with descriptor %v, want 0",
126-
args.params, backend.libec_desc)
127-
backend.Close()
126+
args.params, backend.libecDesc)
127+
_ = backend.Close()
128128
}
129129
}
130130
}
@@ -174,7 +174,7 @@ func TestEncodeDecode(t *testing.T) {
174174
if err != nil {
175175
t.Errorf("%v: %v: %q for pattern %d", description, backend, err, patternIndex)
176176
return false
177-
} else if bytes.Compare(data, pattern) != 0 {
177+
} else if !bytes.Equal(data, pattern) {
178178
t.Errorf("%v: Expected %v to roundtrip pattern %d, got %q", description, backend, patternIndex, data)
179179
return false
180180
}
@@ -213,7 +213,7 @@ func TestReconstruct(t *testing.T) {
213213
backend, err := InitBackend(params)
214214
if err != nil {
215215
t.Errorf("Error creating backend %v: %q", params, err)
216-
backend.Close()
216+
_ = backend.Close()
217217
continue
218218
}
219219
for patternIndex, pattern := range testPatterns {
@@ -227,7 +227,7 @@ func TestReconstruct(t *testing.T) {
227227
if err != nil {
228228
t.Errorf("%v: %v: %q for pattern %d", description, backend, err, patternIndex)
229229
return false
230-
} else if bytes.Compare(data, frags[frag_index]) != 0 {
230+
} else if !bytes.Equal(data, frags[frag_index]) {
231231
t.Errorf("%v: Expected %v to roundtrip pattern %d, got %q", description, backend, patternIndex, data)
232232
return false
233233
}
@@ -261,7 +261,7 @@ func TestIsInvalidFragment(t *testing.T) {
261261
backend, err := InitBackend(params)
262262
if err != nil {
263263
t.Errorf("Error creating backend %v: %q", params, err)
264-
backend.Close()
264+
_ = backend.Close()
265265
continue
266266
}
267267
for patternIndex, pattern := range testPatterns {
@@ -340,7 +340,7 @@ func TestIsInvalidFragment(t *testing.T) {
340340
copy(frag[63:67], fragCopy[63:67])
341341
copy(frag[20:25], fragCopy[20:25])
342342

343-
if bytes.Compare(frag, fragCopy) != 0 {
343+
if !bytes.Equal(frag, fragCopy) {
344344
for i, orig := range fragCopy {
345345
if frag[i] != orig {
346346
t.Logf("%v != %v at index %v", frag[i], orig, i)
@@ -349,7 +349,7 @@ func TestIsInvalidFragment(t *testing.T) {
349349
t.Fatal(corruptedByte, frag, fragCopy)
350350
}
351351

352-
frag[corruptedByte] += 1
352+
frag[corruptedByte]++
353353
if !backend.IsInvalidFragment(frag) {
354354
t.Errorf("%v: frag %v unexpectedly valid after incrementing byte %d for pattern %d", backend, index, corruptedByte, patternIndex)
355355
}
@@ -373,25 +373,25 @@ func TestIsInvalidFragment(t *testing.T) {
373373
}
374374

375375
func TestBackendIsAvailable(t *testing.T) {
376-
required_backends := []string{
376+
requiredBackends := []string{
377377
"null",
378378
"flat_xor_hd",
379379
"liberasurecode_rs_vand",
380380
}
381-
optional_backends := []string{
381+
optionalBackends := []string{
382382
"isa_l_rs_vand",
383383
"isa_l_rs_cauchy",
384384
"jerasure_rs_vand",
385385
"jerasure_rs_cauchy",
386386
"shss",
387387
"libphazr",
388388
}
389-
for _, name := range required_backends {
389+
for _, name := range requiredBackends {
390390
if !BackendIsAvailable(name) {
391391
t.Fatalf("%v is not available", name)
392392
}
393393
}
394-
for _, name := range optional_backends {
394+
for _, name := range optionalBackends {
395395
if !BackendIsAvailable(name) {
396396
t.Logf("INFO: backend not available: %v", name)
397397
}
@@ -400,11 +400,11 @@ func TestBackendIsAvailable(t *testing.T) {
400400

401401
func TestAvailableBackends(t *testing.T) {
402402
for _, name := range AvailableBackends() {
403-
backend, err := InitBackend(ErasureCodeParams{Name: name, K: 3, M: 3, HD: 3})
403+
backend, err := InitBackend(Params{Name: name, K: 3, M: 3, HD: 3})
404404
if err != nil {
405405
t.Errorf("Error creating backend %v: %q", name, err)
406406
}
407-
backend.Close()
407+
_ = backend.Close()
408408
}
409409
t.Logf("INFO: found %v/%v available backends", len(AvailableBackends()), len(KnownBackends))
410410
}

0 commit comments

Comments
 (0)