static Set<BookieSocketAddress> getBookiesInThisLedger(LedgerMetadata metadata) { Set<BookieSocketAddress> bookies = new HashSet<BookieSocketAddress>(); for (List<BookieSocketAddress> ensemble : metadata.getAllEnsembles().values()) { bookies.addAll(ensemble); } return bookies; }
private static boolean containBookiesInLastEnsemble(LedgerMetadata lm, Set<BookieSocketAddress> bookies) { if (lm.getAllEnsembles().size() <= 0) { return false; } Long lastKey = lm.getAllEnsembles().lastKey(); List<BookieSocketAddress> lastEnsemble = lm.getAllEnsembles().get(lastKey); return containBookies(lastEnsemble, bookies); }
static Long getLastEnsembleKey(LedgerMetadata metadata) { checkArgument(!metadata.getAllEnsembles().isEmpty(), "Metadata should never be created with no ensembles"); return metadata.getAllEnsembles().lastKey(); }
static List<BookieSocketAddress> getLastEnsembleValue(LedgerMetadata metadata) { checkArgument(!metadata.getAllEnsembles().isEmpty(), "Metadata should never be created with no ensembles"); return metadata.getAllEnsembles().lastEntry().getValue(); }
/** * Get the number of fragments that makeup this ledger. * * @return the count of fragments */ public synchronized long getNumFragments() { return getLedgerMetadata().getAllEnsembles().size(); }
/** * Get the count of unique bookies that own part of this ledger * by going over all the fragments of the ledger. * * @return count of unique bookies */ public synchronized long getNumBookies() { Map<Long, ? extends List<BookieSocketAddress>> m = getLedgerMetadata().getAllEnsembles(); Set<BookieSocketAddress> s = Sets.newHashSet(); for (List<BookieSocketAddress> aList : m.values()) { s.addAll(aList); } return s.size(); }
public static SortedMap<Long, ? extends List<BookieSocketAddress>> bookiesForLedger(final LedgerHandle lh) { return lh.getLedgerMetadata().getAllEnsembles(); }
public static boolean areEntriesOfLedgerStoredInTheBookie(long ledgerId, BookieSocketAddress bookieAddress, LedgerMetadata ledgerMetadata) { Collection<? extends List<BookieSocketAddress>> ensemblesOfSegments = ledgerMetadata.getAllEnsembles().values(); Iterator<? extends List<BookieSocketAddress>> ensemblesOfSegmentsIterator = ensemblesOfSegments.iterator(); List<BookieSocketAddress> ensemble; int segmentNo = 0; while (ensemblesOfSegmentsIterator.hasNext()) { ensemble = ensemblesOfSegmentsIterator.next(); if (ensemble.contains(bookieAddress)) { if (areEntriesOfSegmentStoredInTheBookie(ledgerMetadata, bookieAddress, segmentNo++)) { return true; } } } return false; }
/** * the entry id greater than the given entry-id at which the next ensemble change takes * place. * * @param entryId * @return the entry id of the next ensemble change (-1 if no further ensemble changes) */ static long getNextEnsembleChange(LedgerMetadata metadata, long entryId) { SortedMap<Long, ? extends List<BookieSocketAddress>> tailMap = metadata.getAllEnsembles().tailMap(entryId + 1); if (tailMap.isEmpty()) { return -1; } else { return tailMap.firstKey(); } }
private Map<Long, Integer> inspectLedger(LedgerMetadata metadata, Set<BookieSocketAddress> bookiesToInspect) { Map<Long, Integer> numBookiesToReplacePerEnsemble = new TreeMap<Long, Integer>(); for (Map.Entry<Long, ? extends List<BookieSocketAddress>> ensemble : metadata.getAllEnsembles().entrySet()) { List<BookieSocketAddress> bookieList = ensemble.getValue(); System.out.print(ensemble.getKey() + ":\t"); int numBookiesToReplace = 0; for (BookieSocketAddress bookie : bookieList) { System.out.print(bookie); if (bookiesToInspect.contains(bookie)) { System.out.print("*"); ++numBookiesToReplace; } else { System.out.print(" "); } System.out.print(" "); } System.out.println(); numBookiesToReplacePerEnsemble.put(ensemble.getKey(), numBookiesToReplace); } return numBookiesToReplacePerEnsemble; }
private static LedgerMetadata replaceBookieInEnsembles(LedgerMetadata metadata, BookieSocketAddress oldBookieId, BookieSocketAddress newBookieId) { LedgerMetadataBuilder builder = LedgerMetadataBuilder.from(metadata); for (Map.Entry<Long, ? extends List<BookieSocketAddress>> e : metadata.getAllEnsembles().entrySet()) { List<BookieSocketAddress> newEnsemble = e.getValue().stream() .map(b -> b.equals(oldBookieId) ? newBookieId : b) .collect(Collectors.toList()); builder.replaceEnsembleEntry(e.getKey(), newEnsemble); } return builder.build(); } }
metadata.getAllEnsembles().entrySet()) { writer.append(String.valueOf(entry.getKey())); for (BookieSocketAddress addr : entry.getValue()) {
(metadata) -> { List<BookieSocketAddress> ensemble = metadata.getAllEnsembles().get(fragmentStartId); return oldBookie2NewBookie.keySet().stream().anyMatch(ensemble::contains); }, (currentMetadata) -> { List<BookieSocketAddress> newEnsemble = currentMetadata.getAllEnsembles().get(fragmentStartId) .stream().map((bookie) -> oldBookie2NewBookie.getOrDefault(bookie, bookie)) .collect(Collectors.toList());
metadata.getValue().getAllEnsembles(); for (List<BookieSocketAddress> ensemble : ensembles.values()) {
LedgerFragment(LedgerHandle lh, long firstEntryId, long lastKnownEntryId, Set<Integer> bookieIndexes) { this.ledgerId = lh.getId(); this.firstEntryId = firstEntryId; this.lastKnownEntryId = lastKnownEntryId; this.bookieIndexes = bookieIndexes; this.ensemble = lh.getLedgerMetadata().getEnsembleAt(firstEntryId); this.schedule = lh.getDistributionSchedule(); SortedMap<Long, ? extends List<BookieSocketAddress>> ensembles = lh .getLedgerMetadata().getAllEnsembles(); this.isLedgerClosed = lh.getLedgerMetadata().isClosed() || !ensemble.equals(ensembles.get(ensembles.lastKey())); }
SortedMap<Long, ? extends List<BookieSocketAddress>> ensembles = admin.getLedgerMetadata(lh).getAllEnsembles(); List<BookieSocketAddress> finalEnsemble = ensembles.get(ensembles.lastKey()); Collection<BookieSocketAddress> available = admin.getAvailableBookies();
@Override public void process(Long ledgerId, AsyncCallback.VoidCallback iterCallback) { ledgerManager.readLedgerMetadata(ledgerId).whenComplete( (metadata, exception) -> { if (exception == null) { for (Map.Entry<Long, ? extends List<BookieSocketAddress>> ensemble : metadata.getValue().getAllEnsembles().entrySet()) { for (BookieSocketAddress bookie : ensemble.getValue()) { putLedger(bookie2ledgersMap, bookie.toString(), ledgerId); } } iterCallback.processResult(BKException.Code.OK, null, null); } else if (BKException.getExceptionCode(exception) == BKException.Code.NoSuchLedgerExistsException) { LOG.info("Ignoring replication of already deleted ledger {}", ledgerId); iterCallback.processResult(BKException.Code.OK, null, null); } else { LOG.warn("Unable to read the ledger: {} information", ledgerId); iterCallback.processResult(BKException.getExceptionCode(exception), null, null); } }); } };
new LinkedList<>(ledgerMetadata.getAllEnsembles().entrySet());
public static LedgerMetadataBuilder from(LedgerMetadata other) { LedgerMetadataBuilder builder = new LedgerMetadataBuilder(); builder.metadataFormatVersion = other.getMetadataFormatVersion(); builder.ensembleSize = other.getEnsembleSize(); builder.writeQuorumSize = other.getWriteQuorumSize(); builder.ackQuorumSize = other.getAckQuorumSize(); builder.state = other.getState(); if (builder.state == State.CLOSED) { builder.lastEntryId = Optional.of(other.getLastEntryId()); builder.length = Optional.of(other.getLength()); } builder.ensembles.putAll(other.getAllEnsembles()); if (other.hasPassword()) { builder.password = Optional.of(other.getPassword()); builder.digestType = Optional.of(other.getDigestType()); } builder.ctime = other.getCtime(); /** Hack to get around fact that ctime was never versioned correctly */ builder.storeCtime = LedgerMetadataUtils.shouldStoreCtime(other); builder.customMetadata = ImmutableMap.copyOf(other.getCustomMetadata()); return builder; }
for (Map.Entry<Long, ? extends List<BookieSocketAddress>> entry : metadata.getAllEnsembles().entrySet()) { LedgerMetadataFormat.Segment.Builder segmentBuilder = LedgerMetadataFormat.Segment.newBuilder(); segmentBuilder.setFirstEntryId(entry.getKey());