/**
* Fences a ledger. From this point on, clients will be unable to write to this ledger. Only
* recoveryAddEntry will be able to add entries to the ledger. This method is idempotent. Once a
* ledger is fenced, it can never be unfenced. Fencing a fenced ledger has no effect.
*/
public SettableFuture<Boolean> fenceLedger(long ledgerId, byte[] masterKey)
throws IOException, BookieException {
LedgerDescriptor handle = handles.getHandle(ledgerId, masterKey);
boolean success;
synchronized (handle) {
success = handle.setFenced();
}
if (success) {
// fenced first time, we should add the key to journal ensure we can rebuild
ByteBuffer bb = ByteBuffer.allocate(8 + 8);
bb.putLong(ledgerId);
bb.putLong(METAENTRY_ID_FENCE_KEY);
bb.flip();
FutureWriteCallback fwc = new FutureWriteCallback();
LOG.debug("record fenced state for ledger {} in journal.", ledgerId);
journal.logAddEntry(bb, fwc, null);
return fwc.getResult();
} else {
// already fenced
SettableFuture<Boolean> successFuture = SettableFuture.create();
successFuture.set(true);
return successFuture;
}
}
/**
* Add entry to a ledger.
*
* @throws BookieException.LedgerFencedException if the ledger is fenced
*/
public void addEntry(ByteBuffer entry, WriteCallback cb, Object ctx, byte[] masterKey)
throws IOException, BookieException {
long requestNanos = MathUtils.nowInNano();
boolean success = false;
try {
LedgerDescriptor handle = getLedgerForEntry(entry, masterKey);
synchronized (handle) {
if (handle.isFenced()) {
throw BookieException.create(BookieException.Code.LedgerFencedException);
}
addEntryInternal(handle, entry, cb, ctx);
}
success = true;
} catch (NoWritableLedgerDirException e) {
transitionToReadOnlyMode();
throw new IOException(e);
} finally {
long elapsedMicros = MathUtils.elapsedMicroSec(requestNanos);
if (success) {
addEntryStats.registerSuccessfulEvent(elapsedMicros);
} else {
addEntryStats.registerFailedEvent(elapsedMicros);
}
}
}
/** Add an entry to a ledger as specified by handle. */
private void addEntryInternal(
LedgerDescriptor handle, ByteBuffer entry, WriteCallback cb, Object ctx)
throws IOException, BookieException {
long ledgerId = handle.getLedgerId();
entry.rewind();
long entryId = handle.addEntry(entry);
entry.rewind();
LOG.trace("Adding {}@{}", entryId, ledgerId);
journal.logAddEntry(entry, cb, ctx);
}
public long readLastAddConfirmed(long ledgerId) throws IOException {
long requestNanos = MathUtils.nowInNano();
boolean success = false;
try {
LedgerDescriptor handle = handles.getReadOnlyHandle(ledgerId);
long lac = handle.getLastAddConfirmed();
success = true;
return lac;
} finally {
long elapsedMicros = MathUtils.elapsedMicroSec(requestNanos);
if (success) {
readLastConfirmedStats.registerSuccessfulEvent(elapsedMicros);
} else {
readLastConfirmedStats.registerFailedEvent(elapsedMicros);
}
}
}
public ByteBuffer readEntry(long ledgerId, long entryId) throws IOException, NoLedgerException {
long requestNanos = MathUtils.nowInNano();
boolean success = false;
try {
LedgerDescriptor handle = handles.getReadOnlyHandle(ledgerId);
LOG.trace("Reading {}@{}", entryId, ledgerId);
ByteBuffer data = handle.readEntry(entryId);
success = true;
return data;
} finally {
long elapsedMicros = MathUtils.elapsedMicroSec(requestNanos);
if (success) {
readEntryStats.registerSuccessfulEvent(elapsedMicros);
} else {
readEntryStats.registerFailedEvent(elapsedMicros);
}
}
}
public Observable waitForLastAddConfirmedUpdate(
long ledgerId, long previoisLAC, Observer observer) throws IOException {
LedgerDescriptor handle = handles.getReadOnlyHandle(ledgerId);
return handle.waitForLastAddConfirmedUpdate(previoisLAC, observer);
}
protected void addEntryByLedgerId(long ledgerId, ByteBuffer entry)
throws IOException, BookieException {
byte[] key = ledgerStorage.readMasterKey(ledgerId);
LedgerDescriptor handle = handles.getHandle(ledgerId, key);
handle.addEntry(entry);
}