Skip to content

Commit 36b7869

Browse files
MMcMMMcM
committed
Fix Spotbugs findings.
1 parent 50ad099 commit 36b7869

File tree

4 files changed

+97
-50
lines changed

4 files changed

+97
-50
lines changed

‎fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/provider/common/TransformedRecordSerializer.java

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -102,45 +102,45 @@ protected TransformedRecordSerializer(@Nonnull RecordSerializer<M> inner,
102102
protected void compress(@Nonnull TransformedRecordSerializerState state, @Nullable StoreTimer timer) {
103103
long startTime = System.nanoTime();
104104

105-
increment(timer, Counts.RECORD_BYTES_BEFORE_COMPRESSION, state.length);
105+
increment(timer, Counts.RECORD_BYTES_BEFORE_COMPRESSION, state.getLength());
106106

107107
// compressed data stores 5 bytes of header info. Hence, it is only fruitful to compress if the uncompressed data
108108
// has more than 5 bytes otherwise the compressed data will always be more than the original.
109-
if (state.length > 5) {
109+
if (state.getLength() > 5) {
110110
// Compressed bytes have 5 bytes of prefixed information about the compression state.
111-
byte[] compressed = new byte[state.length];
111+
byte[] compressed = new byte[state.getLength()];
112112

113113
// Actually compress. If we end up filling the buffer, then just
114114
// return the uncompressed value because it's pointless to compress
115115
// if we actually increase the amount of data.
116116
Deflater compressor = new Deflater(compressionLevel);
117117
int compressedLength;
118118
try {
119-
compressor.setInput(state.data, state.offset, state.length);
119+
compressor.setInput(state.getData(), state.getOffset(), state.getLength());
120120
compressor.finish(); // necessary to include checksum
121121
compressedLength = compressor.deflate(compressed, 5, compressed.length - 5, Deflater.FULL_FLUSH);
122122
} finally {
123123
compressor.end();
124124
}
125125
if (compressedLength == compressed.length - 5) {
126-
increment(timer, Counts.RECORD_BYTES_AFTER_COMPRESSION, state.length);
127-
state.compressed = false;
126+
increment(timer, Counts.RECORD_BYTES_AFTER_COMPRESSION, state.getLength());
127+
state.setCompressed(false);
128128
} else {
129129
// Write compression version number and uncompressed size as these
130130
// meta-data are needed when decompressing.
131131
compressed[0] = (byte)MAX_COMPRESSION_VERSION;
132-
ByteBuffer.wrap(compressed, 1, 4).order(ByteOrder.BIG_ENDIAN).putInt(state.length);
133-
state.compressed = true;
132+
ByteBuffer.wrap(compressed, 1, 4).order(ByteOrder.BIG_ENDIAN).putInt(state.getLength());
133+
state.setCompressed(true);
134134
increment(timer, Counts.RECORD_BYTES_AFTER_COMPRESSION, compressedLength + 5);
135135
state.setDataArray(compressed, 0, compressedLength + 5);
136136
}
137137
} else {
138-
increment(timer, Counts.RECORD_BYTES_AFTER_COMPRESSION, state.length);
138+
increment(timer, Counts.RECORD_BYTES_AFTER_COMPRESSION, state.getLength());
139139
}
140140

141141
if (timer != null) {
142142
timer.recordSinceNanoTime(Events.COMPRESS_SERIALIZED_RECORD, startTime);
143-
if (!state.compressed) {
143+
if (!state.isCompressed()) {
144144
timer.increment(Counts.ESCHEW_RECORD_COMPRESSION);
145145
}
146146
}
@@ -200,18 +200,18 @@ protected void decompress(@Nonnull TransformedRecordSerializerState state, @Null
200200
// we after we've verified it is in the right range, we
201201
// can just move on. If we ever introduce a new format version,
202202
// we will need to make this code more complicated.
203-
int compressionVersion = state.data[state.offset];
203+
int compressionVersion = state.getData()[state.getOffset()];
204204
if (compressionVersion < MIN_COMPRESSION_VERSION || compressionVersion > MAX_COMPRESSION_VERSION) {
205205
throw new RecordSerializationException("unknown compression version")
206206
.addLogInfo("compressionVersion", compressionVersion);
207207
}
208208

209-
int decompressedLength = ByteBuffer.wrap(state.data, state.offset + 1, 4).order(ByteOrder.BIG_ENDIAN).getInt();
209+
int decompressedLength = ByteBuffer.wrap(state.getData(), state.getOffset() + 1, 4).order(ByteOrder.BIG_ENDIAN).getInt();
210210
byte[] decompressed = new byte[decompressedLength];
211211

212212
Inflater decompressor = new Inflater();
213213
try {
214-
decompressor.setInput(state.data, state.offset + 5, state.length - 5);
214+
decompressor.setInput(state.getData(), state.getOffset() + 5, state.getLength() - 5);
215215
int actualDecompressedSize = decompressor.inflate(decompressed);
216216
if (actualDecompressedSize < decompressedLength) {
217217
throw new RecordSerializationException("decompressed record too small")
@@ -247,7 +247,7 @@ public M deserialize(@Nonnull RecordMetaData metaData,
247247
if (!TransformedRecordSerializerPrefix.decodePrefix(state, primaryKey)) {
248248
return inner.deserialize(metaData, primaryKey, serialized, timer);
249249
}
250-
if (state.encrypted) {
250+
if (state.isEncrypted()) {
251251
try {
252252
decrypt(state, timer);
253253
} catch (RecordCoreException ex) {
@@ -259,7 +259,7 @@ public M deserialize(@Nonnull RecordMetaData metaData,
259259
.addLogInfo(LogMessageKeys.PRIMARY_KEY, primaryKey);
260260
}
261261
}
262-
if (state.compressed) {
262+
if (state.isCompressed()) {
263263
try {
264264
decompress(state, timer);
265265
} catch (RecordCoreException ex) {

‎fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/provider/common/TransformedRecordSerializerJCE.java

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,7 @@ protected void encrypt(@Nonnull TransformedRecordSerializerState state, @Nullabl
6060
long startTime = System.nanoTime();
6161

6262
int keyNumber = keyManager.getSerializationKey();
63-
state.keyNumber = keyNumber;
63+
state.setKeyNumber(keyNumber);
6464

6565
byte[] ivData = new byte[CipherPool.IV_SIZE];
6666
keyManager.getRandom(keyNumber).nextBytes(ivData);
@@ -76,7 +76,7 @@ protected void encrypt(@Nonnull TransformedRecordSerializerState state, @Nullabl
7676
byte[] serialized = new byte[totalSize];
7777
System.arraycopy(iv.getIV(), 0, serialized, 0, CipherPool.IV_SIZE);
7878
System.arraycopy(cipherText, 0, serialized, CipherPool.IV_SIZE, cipherText.length);
79-
state.encrypted = true;
79+
state.setEncrypted(true);
8080
state.setDataArray(serialized);
8181
} finally {
8282
CipherPool.returnCipher(cipher);
@@ -94,14 +94,14 @@ protected void decrypt(@Nonnull TransformedRecordSerializerState state, @Nullabl
9494
long startTime = System.nanoTime();
9595

9696
byte[] ivData = new byte[CipherPool.IV_SIZE];
97-
System.arraycopy(state.data, state.offset, ivData, 0, CipherPool.IV_SIZE);
97+
System.arraycopy(state.getData(), state.getOffset(), ivData, 0, CipherPool.IV_SIZE);
9898
IvParameterSpec iv = new IvParameterSpec(ivData);
9999

100-
byte[] cipherText = new byte[state.length - CipherPool.IV_SIZE];
101-
System.arraycopy(state.data, state.offset + CipherPool.IV_SIZE, cipherText, 0, cipherText.length);
102-
Cipher cipher = CipherPool.borrowCipher(keyManager.getCipher(state.keyNumber));
100+
byte[] cipherText = new byte[state.getLength() - CipherPool.IV_SIZE];
101+
System.arraycopy(state.getData(), state.getOffset() + CipherPool.IV_SIZE, cipherText, 0, cipherText.length);
102+
Cipher cipher = CipherPool.borrowCipher(keyManager.getCipher(state.getKeyNumber()));
103103
try {
104-
cipher.init(Cipher.DECRYPT_MODE, keyManager.getKey(state.keyNumber), iv);
104+
cipher.init(Cipher.DECRYPT_MODE, keyManager.getKey(state.getKeyNumber()), iv);
105105

106106
byte[] plainText = cipher.doFinal(cipherText);
107107
state.setDataArray(plainText);

‎fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/provider/common/TransformedRecordSerializerPrefix.java

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -84,29 +84,29 @@ public static boolean decodePrefix(@Nonnull TransformedRecordSerializerState sta
8484
if (type == PREFIX_CLEAR && remaining != 0) {
8585
return false; // Does not have a prefix
8686
}
87-
boolean valid;
87+
boolean valid = true;
8888
switch (type) {
8989
case PREFIX_CLEAR:
90-
valid = true;
9190
break;
9291
case PREFIX_COMPRESSED_THEN_ENCRYPTED:
93-
valid = state.encrypted = state.compressed = true;
92+
state.setEncrypted(true);
93+
state.setCompressed(true);
9494
break;
9595
case PREFIX_ENCRYPTED:
96-
valid = state.encrypted = true;
96+
state.setEncrypted(true);
9797
break;
9898
case PREFIX_COMPRESSED:
99-
valid = state.compressed = true;
99+
state.setCompressed(true);
100100
break;
101101
default:
102102
valid = false;
103103
break;
104104
}
105-
if (state.encrypted) {
105+
if (state.isEncrypted()) {
106106
if (remaining < Integer.MIN_VALUE || remaining > Integer.MAX_VALUE) {
107107
valid = false;
108108
} else {
109-
state.keyNumber = (int)remaining;
109+
state.setKeyNumber((int)remaining);
110110
}
111111
} else if (remaining != 0) {
112112
valid = false;
@@ -121,22 +121,22 @@ public static boolean decodePrefix(@Nonnull TransformedRecordSerializerState sta
121121

122122
public static void encodePrefix(@Nonnull TransformedRecordSerializerState state) {
123123
long prefix;
124-
if (!state.compressed && !state.encrypted) {
124+
if (!state.isCompressed() && !state.isEncrypted()) {
125125
prefix = PREFIX_CLEAR;
126126
} else {
127127
prefix = 0;
128-
if (state.compressed) {
128+
if (state.isCompressed()) {
129129
prefix |= PREFIX_COMPRESSED;
130130
}
131-
if (state.encrypted) {
131+
if (state.isEncrypted()) {
132132
prefix |= PREFIX_ENCRYPTED;
133-
prefix |= (long)state.keyNumber << KEY_SHIFT;
133+
prefix |= (long)state.getKeyNumber() << KEY_SHIFT;
134134
}
135135
}
136-
int size = state.length + varintSize(prefix);
136+
int size = state.getLength() + varintSize(prefix);
137137
byte[] serialized = new byte[size];
138138
int offset = writeVarint(serialized, prefix);
139-
System.arraycopy(state.data, state.offset, serialized, offset, state.length);
139+
System.arraycopy(state.getData(), state.getOffset(), serialized, offset, state.getLength());
140140
state.setDataArray(serialized);
141141
}
142142

@@ -153,11 +153,11 @@ protected static long readVarint(@Nonnull TransformedRecordSerializerState state
153153
long varint = 0;
154154
int nbytes = 0;
155155
while (true) {
156-
if (nbytes >= state.length) {
156+
if (nbytes >= state.getLength()) {
157157
throw new RecordSerializationException("transformation prefix malformed")
158158
.addLogInfo(LogMessageKeys.PRIMARY_KEY, primaryKey);
159159
}
160-
final byte b = state.data[state.offset + nbytes];
160+
final byte b = state.getData()[state.getOffset() + nbytes];
161161
if (nbytes == 9 && (b & 0xFE) != 0) {
162162
// Continuing or more than just the 64th bit.
163163
// This also detects random garbage with the sign bits on.
@@ -170,8 +170,8 @@ protected static long readVarint(@Nonnull TransformedRecordSerializerState state
170170
break;
171171
}
172172
}
173-
state.offset += nbytes;
174-
state.length -= nbytes;
173+
state.setOffset(state.getOffset() + nbytes);
174+
state.setLength(state.getLength() - nbytes);
175175
return varint;
176176
}
177177

‎fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/provider/common/TransformedRecordSerializerState.java

Lines changed: 58 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -25,35 +25,82 @@
2525
import javax.annotation.Nonnull;
2626
import java.util.Arrays;
2727

28+
/**
29+
* The internal state of serialization / deserialization, pointing to a portion of a byte array.
30+
* Also includes information on intended / found serialization format.
31+
*/
2832
@SpotBugsSuppressWarnings("EI_EXPOSE_REP")
2933
class TransformedRecordSerializerState {
30-
public boolean compressed;
31-
public boolean encrypted;
32-
public int keyNumber;
34+
private boolean compressed;
35+
private boolean encrypted;
36+
private int keyNumber;
3337

3438
@Nonnull
35-
public byte[] data;
36-
public int offset;
37-
public int length;
39+
private byte[] data;
40+
private int offset;
41+
private int length;
3842

3943
public TransformedRecordSerializerState(@Nonnull byte[] data) {
4044
this(data, 0, data.length);
4145
}
4246

4347
public TransformedRecordSerializerState(@Nonnull byte[] data, int offset, int length) {
44-
this.compressed = false;
45-
this.encrypted = false;
4648
this.data = data;
4749
this.offset = offset;
4850
this.length = length;
4951
}
5052

53+
public boolean isCompressed() {
54+
return compressed;
55+
}
56+
57+
public void setCompressed(boolean compressed) {
58+
this.compressed = compressed;
59+
}
60+
61+
public boolean isEncrypted() {
62+
return encrypted;
63+
}
64+
65+
public void setEncrypted(boolean encrypted) {
66+
this.encrypted = encrypted;
67+
}
68+
69+
public int getKeyNumber() {
70+
return keyNumber;
71+
}
72+
73+
public void setKeyNumber(int keyNumber) {
74+
this.keyNumber = keyNumber;
75+
}
76+
77+
@Nonnull
78+
public byte[] getData() {
79+
return data;
80+
}
81+
82+
public int getOffset() {
83+
return offset;
84+
}
85+
86+
public void setOffset(int offset) {
87+
this.offset = offset;
88+
}
89+
90+
public int getLength() {
91+
return length;
92+
}
93+
94+
public void setLength(int length) {
95+
this.length = length;
96+
}
97+
5198
@Nonnull
5299
public byte[] getDataArray() {
53-
if (offset == 0 && length == data.length) {
54-
return data;
100+
if (getOffset() == 0 && getLength() == getData().length) {
101+
return getData();
55102
} else {
56-
byte[] newData = Arrays.copyOfRange(data, offset, offset + length);
103+
byte[] newData = Arrays.copyOfRange(getData(), getOffset(), getOffset() + getLength());
57104
offset = 0;
58105
length = newData.length;
59106
data = newData;

0 commit comments

Comments
 (0)