// Received an ACK
@Override
public void onAck() {
// remove local cache but NOT in case it is already on disk
// (ie memory can be reclaimed and we assume we have plenty of disk space)
if (_dontCache && !_xval.isPersisted()) H2O.putIfMatch(_xkey, null, _xval);
if (_xval != null) _xval.completeRemotePut();
}
// Read up to 'len' bytes of Value. Value should already be persisted to
// disk. A racing delete can trigger a failure where we get a null return,
// but no crash (although one could argue that a racing load&delete is a bug
// no matter what).
@Override
public byte[] load(Value v) {
long skip = 0;
Key k = v._key;
// Convert an arraylet chunk into a long-offset from the base file.
if (k._kb[0] == Key.ARRAYLET_CHUNK) {
skip = ValueArray.getChunkOffset(k); // The offset
k = ValueArray.getArrayKey(k); // From the base file key
}
if (k._kb[0] == Key.DVEC) {
skip = water.fvec.NFSFileVec.chunkOffset(k); // The offset
}
try {
FileInputStream s = null;
try {
s = new FileInputStream(getFileForKey(k));
FileChannel fc = s.getChannel();
fc.position(skip);
AutoBuffer ab = new AutoBuffer(fc, true, Value.NFS);
byte[] b = ab.getA1(v._max);
ab.close();
assert v.isPersisted();
return b;
} finally {
if (s != null) s.close();
}
} catch (IOException e) { // Broken disk / short-file???
H2O.ignore(e);
return null;
}
}
@Override
public void store(Value v) {
// Should be used only if ice goes to HDFS
assert this == getIce();
assert !v.isPersisted();
byte[] m = v.memOrLoad();
assert (m == null || m.length == v._max); // Assert not saving partial files
store(new Path(_iceRoot, getIceName(v)), m);
v.setdsk(); // Set as write-complete to disk
}
@Override
public void delete(final Value v) {
assert this == getIce();
assert !v.isPersisted(); // Upper layers already cleared out
run(
new Callable() {
@Override
public Object call() throws Exception {
Path p = new Path(_iceRoot, getIceName(v));
FileSystem fs = FileSystem.get(p.toUri(), CONF);
fs.delete(p, true);
if (v.isArray()) { // Also nuke directory if the top-level ValueArray dies
p = new Path(_iceRoot, getIceDirectory(v._key));
fs = FileSystem.get(p.toUri(), CONF);
fs.delete(p, true);
}
return null;
}
},
false,
0);
}
// Store Value v to disk.
static void fileStore(Value v) {
// Only the home node does persistence on NFS
if (!v._key.home()) return;
// A perhaps useless cutout: the upper layers should test this first.
if (v.isPersisted()) return;
// Never store arraylets on NFS, instead we'll store the entire array.
assert !v.isArray();
try {
File f = getFileForKey(v._key);
f.mkdirs();
FileOutputStream s = new FileOutputStream(f);
try {
byte[] m = v.memOrLoad();
assert (m == null || m.length == v._max); // Assert not saving partial files
if (m != null) new AutoBuffer(s.getChannel(), false, Value.NFS).putA1(m, m.length).close();
v.setdsk(); // Set as write-complete to disk
} finally {
s.close();
}
} catch (IOException e) {
H2O.ignore(e);
}
}
