_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q21600 | RaftClusterContext.resetJoinTimer | train | private void resetJoinTimer() {
cancelJoinTimer();
joinTimeout = raft.getThreadContext().schedule(raft.getElectionTimeout().multipliedBy(2), () -> {
join(getActiveMemberStates().iterator());
});
} | java | {
"resource": ""
} |
q21601 | DefaultAsyncDistributedLogPartition.produce | train | CompletableFuture<Void> produce(byte[] bytes) {
return session.producer().append(bytes).thenApply(v -> null);
} | java | {
"resource": ""
} |
q21602 | AbstractPrimitiveService.configure | train | private void configure(OperationId operationId, Method method, ServiceExecutor executor) {
if (method.getReturnType() == Void.TYPE) {
if (method.getParameterTypes().length == 0) {
executor.register(operationId, () -> {
try {
method.invoke(this);
} catch (IllegalAccessEx... | java | {
"resource": ""
} |
q21603 | RaftStorage.lock | train | public boolean lock(String id) {
File file = new File(directory, String.format(".%s.lock", prefix));
try {
if (file.createNewFile()) {
try (FileBuffer buffer = FileBuffer.allocate(file)) {
buffer.writeString(id).flush();
}
return true;
} else {
try (FileBuff... | java | {
"resource": ""
} |
q21604 | RaftStorage.deleteFiles | train | private void deleteFiles(Predicate<File> predicate) {
directory.mkdirs();
// Iterate through all files in the storage directory.
for (File file : directory.listFiles(f -> f.isFile() && predicate.test(f))) {
try {
Files.delete(file.toPath());
} catch (IOException e) {
// Ignore t... | java | {
"resource": ""
} |
q21605 | LeaderRole.drainCommands | train | private void drainCommands(long sequenceNumber, RaftSession session) {
// First we need to drain any commands that exist in the queue *prior* to the next sequence number. This is
// possible if commands from the prior term are committed after a leader change.
long nextSequence = session.nextRequestSequence(... | java | {
"resource": ""
} |
q21606 | LeaderRole.commitCommand | train | private void commitCommand(CommandRequest request, CompletableFuture<CommandResponse> future) {
final long term = raft.getTerm();
final long timestamp = System.currentTimeMillis();
CommandEntry command = new CommandEntry(term, timestamp, request.session(), request.sequenceNumber(), request.operation());
... | java | {
"resource": ""
} |
q21607 | LeaderRole.failPendingCommands | train | private void failPendingCommands() {
for (RaftSession session : raft.getSessions().getSessions()) {
for (PendingCommand command : session.clearCommands()) {
command.future().complete(logResponse(CommandResponse.builder()
.withStatus(RaftResponse.Status.ERROR)
.withError(RaftErr... | java | {
"resource": ""
} |
q21608 | SetUpdate.map | train | public <T> SetUpdate<T> map(Function<E, T> mapper) {
return new SetUpdate<T>(type, mapper.apply(element));
} | java | {
"resource": ""
} |
q21609 | HeartbeatMembershipProtocol.handleDiscoveryEvent | train | private void handleDiscoveryEvent(NodeDiscoveryEvent event) {
switch (event.type()) {
case JOIN:
handleJoinEvent(event.subject());
break;
case LEAVE:
handleLeaveEvent(event.subject());
break;
default:
throw new AssertionError();
}
} | java | {
"resource": ""
} |
q21610 | HeartbeatMembershipProtocol.sendHeartbeats | train | private CompletableFuture<Void> sendHeartbeats() {
checkMetadata();
Stream<GossipMember> clusterMembers = members.values().stream()
.filter(member -> !member.id().equals(localMember.id()));
Stream<GossipMember> providerMembers = discoveryService.getNodes().stream()
.filter(node -> !members.... | java | {
"resource": ""
} |
q21611 | HeartbeatMembershipProtocol.sendHeartbeat | train | private CompletableFuture<Void> sendHeartbeat(GossipMember member) {
return bootstrapService.getMessagingService().sendAndReceive(member.address(), HEARTBEAT_MESSAGE, SERIALIZER.encode(localMember))
.whenCompleteAsync((response, error) -> {
if (error == null) {
Collection<GossipMember>... | java | {
"resource": ""
} |
q21612 | HeartbeatMembershipProtocol.handleHeartbeat | train | private byte[] handleHeartbeat(Address address, byte[] message) {
GossipMember remoteMember = SERIALIZER.decode(message);
LOGGER.trace("{} - Received heartbeat: {}", localMember.id(), remoteMember);
failureDetectors.computeIfAbsent(remoteMember.id(), n -> new PhiAccrualFailureDetector()).report();
updat... | java | {
"resource": ""
} |
q21613 | HeartbeatMembershipProtocol.updateMember | train | private void updateMember(GossipMember remoteMember, boolean direct) {
GossipMember localMember = members.get(remoteMember.id());
if (localMember == null) {
remoteMember.setActive(true);
remoteMember.setReachable(true);
members.put(remoteMember.id(), remoteMember);
post(new GroupMembersh... | java | {
"resource": ""
} |
q21614 | NodeConfig.setAddress | train | @Deprecated
public NodeConfig setAddress(Address address) {
this.host = address.host();
this.port = address.port();
return this;
} | java | {
"resource": ""
} |
q21615 | UpdateEntry.isNewerThan | train | public boolean isNewerThan(UpdateEntry other) {
return other == null || other.value == null || (value != null && value.isNewerThan(other.value));
} | java | {
"resource": ""
} |
q21616 | DocumentPath.childPath | train | public DocumentPath childPath() {
if (pathElements.size() <= 1) {
return null;
}
return new DocumentPath(this.pathElements.subList(pathElements.size() - 1, pathElements.size()));
} | java | {
"resource": ""
} |
q21617 | DocumentPath.parent | train | public DocumentPath parent() {
if (pathElements.size() <= 1) {
return null;
}
return new DocumentPath(this.pathElements.subList(0, pathElements.size() - 1));
} | java | {
"resource": ""
} |
q21618 | DocumentPath.leastCommonAncestor | train | public static DocumentPath leastCommonAncestor(Collection<DocumentPath> paths) {
if (paths.isEmpty()) {
return null;
}
return DocumentPath.from(StringUtils.getCommonPrefix(paths.stream()
.map(DocumentPath::toString)
.toArray(String[]::new)));
} | java | {
"resource": ""
} |
q21619 | SlidingWindowCounter.get | train | public long get(int slots) {
checkArgument(slots <= windowSlots,
"Requested window must be less than the total window slots");
long sum = 0;
for (int i = 0; i < slots; i++) {
int currentIndex = headSlot - i;
if (currentIndex < 0) {
currentIndex = counters.size() + currentIndex;... | java | {
"resource": ""
} |
q21620 | Leader.map | train | public <U> Leader<U> map(Function<T, U> mapper) {
return new Leader<>(mapper.apply(id), term, termStartTime);
} | java | {
"resource": ""
} |
q21621 | Leadership.map | train | public <U> Leadership<U> map(Function<T, U> mapper) {
return new Leadership<>(
leader != null ? leader.map(mapper) : null,
candidates.stream().map(mapper).collect(Collectors.toList()));
} | java | {
"resource": ""
} |
q21622 | DistributedLogSession.changeState | train | private synchronized void changeState(PrimitiveState state) {
if (this.state != state) {
this.state = state;
stateChangeListeners.forEach(l -> threadContext.execute(() -> l.accept(state)));
}
} | java | {
"resource": ""
} |
q21623 | DistributedLogSession.term | train | private CompletableFuture<PrimaryTerm> term() {
CompletableFuture<PrimaryTerm> future = new CompletableFuture<>();
threadContext.execute(() -> {
if (term != null) {
future.complete(term);
} else {
primaryElection.getTerm().whenCompleteAsync((term, error) -> {
if (term != nu... | java | {
"resource": ""
} |
q21624 | Atomix.buildSystemPartitionGroup | train | @SuppressWarnings("unchecked")
private static ManagedPartitionGroup buildSystemPartitionGroup(AtomixConfig config) {
PartitionGroupConfig<?> partitionGroupConfig = config.getManagementGroup();
if (partitionGroupConfig == null) {
return null;
}
return partitionGroupConfig.getType().newPartitionGr... | java | {
"resource": ""
} |
q21625 | Atomix.buildPartitionService | train | @SuppressWarnings("unchecked")
private static ManagedPartitionService buildPartitionService(
AtomixConfig config,
ClusterMembershipService clusterMembershipService,
ClusterCommunicationService messagingService,
AtomixRegistry registry) {
List<ManagedPartitionGroup> partitionGroups = new Ar... | java | {
"resource": ""
} |
q21626 | PrimitiveId.from | train | public static PrimitiveId from(String id) {
return from(Hashing.sha256().hashString(id, StandardCharsets.UTF_8).asLong());
} | java | {
"resource": ""
} |
q21627 | FileSnapshot.delete | train | @Override
public void delete() {
LOGGER.debug("Deleting {}", this);
Path path = file.file().toPath();
if (Files.exists(path)) {
try {
Files.delete(file.file().toPath());
} catch (IOException e) {
}
}
} | java | {
"resource": ""
} |
q21628 | AtomixConfig.setPartitionGroups | train | public AtomixConfig setPartitionGroups(Map<String, PartitionGroupConfig<?>> partitionGroups) {
partitionGroups.forEach((name, group) -> group.setName(name));
this.partitionGroups = partitionGroups;
return this;
} | java | {
"resource": ""
} |
q21629 | AtomixConfig.getPrimitiveDefault | train | @SuppressWarnings("unchecked")
public <C extends PrimitiveConfig<C>> C getPrimitiveDefault(String name) {
return (C) primitiveDefaults.get(name);
} | java | {
"resource": ""
} |
q21630 | AtomixConfig.addPrimitive | train | public AtomixConfig addPrimitive(String name, PrimitiveConfig config) {
primitives.put(name, config);
return this;
} | java | {
"resource": ""
} |
q21631 | AtomixConfig.getPrimitive | train | @SuppressWarnings("unchecked")
public <C extends PrimitiveConfig<C>> C getPrimitive(String name) {
return (C) primitives.get(name);
} | java | {
"resource": ""
} |
q21632 | RaftServiceManager.isRunningOutOfDiskSpace | train | private boolean isRunningOutOfDiskSpace() {
// If there's not enough space left to allocate two log segments
return raft.getStorage().statistics().getUsableSpace() < raft.getStorage().maxLogSegmentSize() * SEGMENT_BUFFER_FACTOR
// Or the used disk percentage has surpassed the free disk buffer percentage... | java | {
"resource": ""
} |
q21633 | RaftServiceManager.isRunningOutOfMemory | train | private boolean isRunningOutOfMemory() {
StorageLevel level = raft.getStorage().storageLevel();
if (level == StorageLevel.MEMORY || level == StorageLevel.MAPPED) {
long freeMemory = raft.getStorage().statistics().getFreeMemory();
long totalMemory = raft.getStorage().statistics().getTotalMemory();
... | java | {
"resource": ""
} |
q21634 | RaftServiceManager.takeSnapshots | train | private CompletableFuture<Void> takeSnapshots(boolean rescheduleAfterCompletion, boolean force) {
// If compaction is already in progress, return the existing future and reschedule if this is a scheduled compaction.
if (compactFuture != null) {
if (rescheduleAfterCompletion) {
compactFuture.whenCo... | java | {
"resource": ""
} |
q21635 | RaftServiceManager.takeSnapshots | train | private CompletableFuture<Snapshot> takeSnapshots() {
ComposableFuture<Snapshot> future = new ComposableFuture<>();
stateContext.execute(() -> {
try {
future.complete(snapshot());
} catch (Exception e) {
future.completeExceptionally(e);
}
});
return future;
} | java | {
"resource": ""
} |
q21636 | RaftServiceManager.scheduleCompletion | train | private void scheduleCompletion(Snapshot snapshot) {
stateContext.schedule(SNAPSHOT_COMPLETION_DELAY, () -> {
if (completeSnapshot(snapshot.index())) {
logger.debug("Completing snapshot {}", snapshot.index());
snapshot.complete();
// If log compaction is being forced, immediately compa... | java | {
"resource": ""
} |
q21637 | RaftServiceManager.scheduleCompaction | train | private void scheduleCompaction(long lastApplied) {
// Schedule compaction after a randomized delay to discourage snapshots on multiple nodes at the same time.
logger.trace("Scheduling compaction in {}", COMPACT_DELAY);
stateContext.schedule(COMPACT_DELAY, () -> compactLogs(lastApplied));
} | java | {
"resource": ""
} |
q21638 | RaftServiceManager.compactLogs | train | private void compactLogs(long compactIndex) {
raft.getThreadContext().execute(() -> {
logger.debug("Compacting logs up to index {}", compactIndex);
try {
raft.getLog().compact(compactIndex);
} catch (Exception e) {
logger.error("An exception occurred during log compaction: {}", e);... | java | {
"resource": ""
} |
q21639 | RaftServiceManager.applyIndex | train | @SuppressWarnings("unchecked")
private void applyIndex(long index) {
// Apply entries prior to this entry.
if (reader.hasNext() && reader.getNextIndex() == index) {
// Read the entry from the log. If the entry is non-null then apply it, otherwise
// simply update the last applied index and return ... | java | {
"resource": ""
} |
q21640 | RaftServiceManager.snapshot | train | Snapshot snapshot() {
Snapshot snapshot = raft.getSnapshotStore().newTemporarySnapshot(raft.getLastApplied(), new WallClockTimestamp());
try (SnapshotWriter writer = snapshot.openWriter()) {
for (RaftServiceContext service : raft.getServices()) {
writer.buffer().mark();
SnapshotWriter serv... | java | {
"resource": ""
} |
q21641 | RaftServiceManager.snapshotService | train | private void snapshotService(SnapshotWriter writer, RaftServiceContext service) {
writer.writeLong(service.serviceId().id());
writer.writeString(service.serviceType().name());
writer.writeString(service.serviceName());
byte[] config = Serializer.using(service.serviceType().namespace()).encode(service.se... | java | {
"resource": ""
} |
q21642 | RaftServiceManager.install | train | void install(Snapshot snapshot) {
logger.debug("Installing snapshot {}", snapshot);
try (SnapshotReader reader = snapshot.openReader()) {
while (reader.hasRemaining()) {
try {
int length = reader.readInt();
if (length > 0) {
SnapshotReader serviceReader = new Snapsh... | java | {
"resource": ""
} |
q21643 | RaftServiceManager.installService | train | private void installService(SnapshotReader reader) {
PrimitiveId primitiveId = PrimitiveId.from(reader.readLong());
try {
PrimitiveType primitiveType = raft.getPrimitiveTypes().getPrimitiveType(reader.readString());
String serviceName = reader.readString();
byte[] serviceConfig = reader.readBy... | java | {
"resource": ""
} |
q21644 | RaftServiceManager.completeSnapshot | train | private boolean completeSnapshot(long index) {
// Compute the lowest completed index for all sessions that belong to this state machine.
long lastCompleted = index;
for (RaftSession session : raft.getSessions().getSessions()) {
lastCompleted = Math.min(lastCompleted, session.getLastCompleted());
}... | java | {
"resource": ""
} |
q21645 | RaftServiceManager.getOrInitializeService | train | private RaftServiceContext getOrInitializeService(PrimitiveId primitiveId, PrimitiveType primitiveType, String serviceName, byte[] config) {
// Get the state machine executor or create one if it doesn't already exist.
RaftServiceContext service = raft.getServices().getService(serviceName);
if (service == nu... | java | {
"resource": ""
} |
q21646 | RaftServiceManager.initializeService | train | @SuppressWarnings("unchecked")
private RaftServiceContext initializeService(PrimitiveId primitiveId, PrimitiveType primitiveType, String serviceName, byte[] config) {
RaftServiceContext oldService = raft.getServices().getService(serviceName);
ServiceConfig serviceConfig = config == null ? new ServiceConfig() ... | java | {
"resource": ""
} |
q21647 | RaftServiceManager.applyOpenSession | train | private long applyOpenSession(Indexed<OpenSessionEntry> entry) {
PrimitiveType primitiveType = raft.getPrimitiveTypes().getPrimitiveType(entry.entry().serviceType());
// Get the state machine executor or create one if it doesn't already exist.
RaftServiceContext service = getOrInitializeService(
Pr... | java | {
"resource": ""
} |
q21648 | RaftServiceManager.applyCloseSession | train | private void applyCloseSession(Indexed<CloseSessionEntry> entry) {
RaftSession session = raft.getSessions().getSession(entry.entry().session());
// If the server session is null, the session either never existed or already expired.
if (session == null) {
throw new RaftException.UnknownSession("Unknow... | java | {
"resource": ""
} |
q21649 | RaftServiceManager.applyMetadata | train | private MetadataResult applyMetadata(Indexed<MetadataEntry> entry) {
// If the session ID is non-zero, read the metadata for the associated state machine.
if (entry.entry().session() > 0) {
RaftSession session = raft.getSessions().getSession(entry.entry().session());
// If the session is null, retu... | java | {
"resource": ""
} |
q21650 | Namespace.serialize | train | public byte[] serialize(final Object obj, final int bufferSize) {
return kryoOutputPool.run(output -> {
return kryoPool.run(kryo -> {
kryo.writeClassAndObject(output, obj);
output.flush();
return output.getByteArrayOutputStream().toByteArray();
});
}, bufferSize);
} | java | {
"resource": ""
} |
q21651 | Namespace.serialize | train | public void serialize(final Object obj, final ByteBuffer buffer) {
ByteBufferOutput out = new ByteBufferOutput(buffer);
Kryo kryo = borrow();
try {
kryo.writeClassAndObject(out, obj);
out.flush();
} finally {
release(kryo);
}
} | java | {
"resource": ""
} |
q21652 | Namespace.serialize | train | public void serialize(final Object obj, final OutputStream stream, final int bufferSize) {
ByteBufferOutput out = new ByteBufferOutput(stream, bufferSize);
Kryo kryo = borrow();
try {
kryo.writeClassAndObject(out, obj);
out.flush();
} finally {
release(kryo);
}
} | java | {
"resource": ""
} |
q21653 | Namespace.deserialize | train | public <T> T deserialize(final byte[] bytes) {
return kryoInputPool.run(input -> {
input.setInputStream(new ByteArrayInputStream(bytes));
return kryoPool.run(kryo -> {
@SuppressWarnings("unchecked")
T obj = (T) kryo.readClassAndObject(input);
return obj;
});
}, DEFAULT_... | java | {
"resource": ""
} |
q21654 | Namespace.deserialize | train | public <T> T deserialize(final ByteBuffer buffer) {
ByteBufferInput in = new ByteBufferInput(buffer);
Kryo kryo = borrow();
try {
@SuppressWarnings("unchecked")
T obj = (T) kryo.readClassAndObject(in);
return obj;
} finally {
release(kryo);
}
} | java | {
"resource": ""
} |
q21655 | Namespace.deserialize | train | public <T> T deserialize(final InputStream stream, final int bufferSize) {
ByteBufferInput in = new ByteBufferInput(stream, bufferSize);
Kryo kryo = borrow();
try {
@SuppressWarnings("unchecked")
T obj = (T) kryo.readClassAndObject(in);
return obj;
} finally {
release(kryo);
... | java | {
"resource": ""
} |
q21656 | Namespace.create | train | @Override
public Kryo create() {
LOGGER.trace("Creating Kryo instance for {}", this);
Kryo kryo = new Kryo();
kryo.setClassLoader(classLoader);
kryo.setRegistrationRequired(registrationRequired);
// If compatible serialization is enabled, override the default serializer.
if (compatible) {
... | java | {
"resource": ""
} |
q21657 | PrimaryBackupSessionClient.handleEvent | train | private void handleEvent(PrimitiveEvent event) {
log.trace("Received {}", event);
Set<Consumer<PrimitiveEvent>> listeners = eventListeners.get(event.type());
if (listeners != null) {
listeners.forEach(l -> l.accept(event));
}
} | java | {
"resource": ""
} |
q21658 | PrimaryBackupSessionClient.connect | train | private void connect(int attempt, CompletableFuture<SessionClient> future) {
if (attempt > MAX_ATTEMPTS) {
future.completeExceptionally(new PrimitiveException.Unavailable());
return;
}
primaryElection.getTerm().whenCompleteAsync((term, error) -> {
if (error == null) {
if (term.pri... | java | {
"resource": ""
} |
q21659 | BlockingDistributedSemaphore.complete | train | private <T> T complete(CompletableFuture<T> future, int acquirePermits) {
AtomicBoolean needRelease = new AtomicBoolean(false);
try {
return future.thenApply(value -> {
if (needRelease.get()) {
if (acquirePermits > 0) {
asyncSemaphore.release(acquirePermits);
}
... | java | {
"resource": ""
} |
q21660 | DefaultDistributedCyclicBarrierService.timeout | train | private void timeout(long barrierId) {
if (this.barrierId == barrierId && !broken) {
broken = true;
parties.forEach(session -> getSession(session).accept(client -> client.broken(barrierId)));
}
} | java | {
"resource": ""
} |
q21661 | DefaultServiceExecutor.runTasks | train | private void runTasks() {
// Execute any tasks that were queue during execution of the command.
if (!tasks.isEmpty()) {
for (Runnable task : tasks) {
log.trace("Executing task {}", task);
task.run();
}
tasks.clear();
}
} | java | {
"resource": ""
} |
q21662 | AbstractAtomicSemaphoreService.release | train | private void release(long sessionId, int releasePermits) {
increaseAvailable(releasePermits);
holders.computeIfPresent(sessionId, (id, acquired) -> {
acquired -= releasePermits;
if (acquired <= 0) {
return null;
}
return acquired;
});
checkAndNotifyWaiters();
} | java | {
"resource": ""
} |
q21663 | Task.map | train | public <F> Task<F> map(Function<E, F> mapper) {
return new Task<>(taskId, mapper.apply(payload));
} | java | {
"resource": ""
} |
q21664 | StorageStatistics.getFreeMemory | train | public long getFreeMemory() {
try {
return (long) mBeanServer.getAttribute(new ObjectName("java.lang", "type", "OperatingSystem"), "FreePhysicalMemorySize");
} catch (Exception e) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("An exception occurred during memory check", e);
}
}
... | java | {
"resource": ""
} |
q21665 | AbstractAppender.handleConfigureResponseOk | train | @SuppressWarnings("unused")
protected void handleConfigureResponseOk(RaftMemberContext member, ConfigureRequest request, ConfigureResponse response) {
// Reset the member failure count and update the member's status if necessary.
succeedAttempt(member);
// Update the member's current configuration term a... | java | {
"resource": ""
} |
q21666 | LogPartition.join | train | CompletableFuture<Partition> join(
PartitionManagementService managementService,
ThreadContextFactory threadFactory) {
election = managementService.getElectionService().getElectionFor(partitionId);
server = new LogPartitionServer(
this,
managementService,
config,
thre... | java | {
"resource": ""
} |
q21667 | EventManager.getEventLog | train | @SuppressWarnings("unchecked")
public <L, E> EventLog<L, E> getEventLog(Class<?> type, String name) {
return eventRegistries.computeIfAbsent(type, t -> new ConcurrentHashMap<>()).get(name);
} | java | {
"resource": ""
} |
q21668 | EventManager.getOrCreateEventLog | train | @SuppressWarnings("unchecked")
public <L, E> EventLog<L, E> getOrCreateEventLog(Class<?> type, String name, Function<EventLog<L, E>, L> listenerFactory) {
return eventRegistries.computeIfAbsent(type, t -> new ConcurrentHashMap<>())
.computeIfAbsent(name, n -> new EventLog<>(listenerFactory));
} | java | {
"resource": ""
} |
q21669 | EventManager.removeEventLog | train | @SuppressWarnings("unchecked")
public <L, E> EventLog<L, E> removeEventLog(Class<?> type, String name) {
return eventRegistries.computeIfAbsent(type, t -> new ConcurrentHashMap<>()).remove(name);
} | java | {
"resource": ""
} |
q21670 | EventManager.getEventLogNames | train | public Set<String> getEventLogNames(Class<?> type) {
return eventRegistries.computeIfAbsent(type, t -> new ConcurrentHashMap<>()).keySet();
} | java | {
"resource": ""
} |
q21671 | PrimaryBackupServerContext.getService | train | private CompletableFuture<PrimaryBackupServiceContext> getService(PrimitiveRequest request) {
return services.computeIfAbsent(request.primitive().name(), n -> {
PrimitiveType primitiveType = primitiveTypes.getPrimitiveType(request.primitive().type());
PrimaryBackupServiceContext service = new PrimaryBac... | java | {
"resource": ""
} |
q21672 | PrimaryBackupServerContext.metadata | train | private CompletableFuture<MetadataResponse> metadata(MetadataRequest request) {
return CompletableFuture.completedFuture(MetadataResponse.ok(services.entrySet().stream()
.filter(entry -> Futures.get(entry.getValue()).serviceType().name().equals(request.primitiveType()))
.map(entry -> entry.getKey())... | java | {
"resource": ""
} |
q21673 | PrimaryBackupServerContext.unregisterListeners | train | private void unregisterListeners() {
protocol.unregisterExecuteHandler();
protocol.unregisterBackupHandler();
protocol.unregisterRestoreHandler();
protocol.unregisterCloseHandler();
protocol.unregisterMetadataHandler();
} | java | {
"resource": ""
} |
q21674 | NettyMessagingService.executeOnTransientConnection | train | private <T> CompletableFuture<T> executeOnTransientConnection(
Address address,
Function<ClientConnection, CompletableFuture<T>> callback,
Executor executor) {
CompletableFuture<T> future = new CompletableFuture<>();
if (address.equals(returnAddress)) {
callback.apply(localConnection).wh... | java | {
"resource": ""
} |
q21675 | NettyMessagingService.bootstrapClient | train | private CompletableFuture<Channel> bootstrapClient(Address address) {
CompletableFuture<Channel> future = new OrderedFuture<>();
Bootstrap bootstrap = new Bootstrap();
bootstrap.option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);
bootstrap.option(ChannelOption.WRITE_BUFFER_WATER_MARK,
... | java | {
"resource": ""
} |
q21676 | NettyMessagingService.bootstrapServer | train | private CompletableFuture<Void> bootstrapServer() {
ServerBootstrap b = new ServerBootstrap();
b.option(ChannelOption.SO_REUSEADDR, true);
b.option(ChannelOption.SO_BACKLOG, 128);
b.childOption(ChannelOption.WRITE_BUFFER_WATER_MARK,
new WriteBufferWaterMark(8 * 1024, 32 * 1024));
b.childOpti... | java | {
"resource": ""
} |
q21677 | StringUtils.split | train | public static String[] split(String input, String regex) {
if (input == null) {
return null;
}
String[] arr = input.split(regex);
List<String> results = new ArrayList<>(arr.length);
for (String a : arr) {
if (!a.trim().isEmpty()) {
results.add(a);
}
}
return results... | java | {
"resource": ""
} |
q21678 | RaftContext.awaitState | train | public void awaitState(State state, Consumer<State> listener) {
if (this.state == state) {
listener.accept(this.state);
} else {
addStateChangeListener(new Consumer<State>() {
@Override
public void accept(State state) {
listener.accept(state);
removeStateChangeLis... | java | {
"resource": ""
} |
q21679 | RaftContext.getLeader | train | public DefaultRaftMember getLeader() {
// Store in a local variable to prevent race conditions and/or multiple volatile lookups.
MemberId leader = this.leader;
return leader != null ? cluster.getMember(leader) : null;
} | java | {
"resource": ""
} |
q21680 | RaftContext.isLeader | train | public boolean isLeader() {
MemberId leader = this.leader;
return leader != null && leader.equals(cluster.getMember().memberId());
} | java | {
"resource": ""
} |
q21681 | RaftContext.setLastApplied | train | public void setLastApplied(long lastApplied) {
this.lastApplied = Math.max(this.lastApplied, lastApplied);
if (state == State.ACTIVE) {
threadContext.execute(() -> {
if (state == State.ACTIVE && this.lastApplied >= firstCommitIndex) {
state = State.READY;
stateChangeListeners.f... | java | {
"resource": ""
} |
q21682 | RaftContext.compact | train | public CompletableFuture<Void> compact() {
ComposableFuture<Void> future = new ComposableFuture<>();
threadContext.execute(() -> stateMachine.compact().whenComplete(future));
return future;
} | java | {
"resource": ""
} |
q21683 | RaftContext.registerHandlers | train | private void registerHandlers(RaftServerProtocol protocol) {
protocol.registerOpenSessionHandler(request -> runOnContextIfReady(() -> role.onOpenSession(request), OpenSessionResponse::builder));
protocol.registerCloseSessionHandler(request -> runOnContextIfReady(() -> role.onCloseSession(request), CloseSessionR... | java | {
"resource": ""
} |
q21684 | RaftContext.unregisterHandlers | train | private void unregisterHandlers(RaftServerProtocol protocol) {
protocol.unregisterOpenSessionHandler();
protocol.unregisterCloseSessionHandler();
protocol.unregisterKeepAliveHandler();
protocol.unregisterMetadataHandler();
protocol.unregisterConfigureHandler();
protocol.unregisterInstallHandler(... | java | {
"resource": ""
} |
q21685 | RaftContext.anoint | train | public CompletableFuture<Void> anoint() {
if (role.role() == RaftServer.Role.LEADER) {
return CompletableFuture.completedFuture(null);
}
CompletableFuture<Void> future = new CompletableFuture<>();
threadContext.execute(() -> {
// Register a leader election listener to wait for the election... | java | {
"resource": ""
} |
q21686 | MemberSelector.state | train | public State state() {
if (selectionsIterator == null) {
return State.RESET;
} else if (hasNext()) {
return State.ITERATE;
} else {
return State.COMPLETE;
}
} | java | {
"resource": ""
} |
q21687 | MemberSelector.reset | train | public MemberSelector reset() {
if (selectionsIterator != null) {
this.selections = strategy.selectConnections(leader, Lists.newLinkedList(members));
this.selectionsIterator = null;
}
return this;
} | java | {
"resource": ""
} |
q21688 | MemberSelector.reset | train | public MemberSelector reset(MemberId leader, Collection<MemberId> members) {
if (changed(leader, members)) {
this.leader = leader != null && members.contains(leader) ? leader : null;
this.members = Sets.newLinkedHashSet(members);
this.selections = strategy.selectConnections(leader, Lists.newLinked... | java | {
"resource": ""
} |
q21689 | CrdtValueDelegate.encode | train | private String encode(Object value) {
return BaseEncoding.base16().encode(valueSerializer.encode(value));
} | java | {
"resource": ""
} |
q21690 | CrdtValueDelegate.decode | train | protected V decode(String value) {
return valueSerializer.decode(BaseEncoding.base16().decode(value));
} | java | {
"resource": ""
} |
q21691 | JournalSegment.map | train | private void map() {
if (storageLevel == StorageLevel.MAPPED) {
MappedByteBuffer buffer = writer.map();
readers.forEach(reader -> reader.map(buffer));
}
} | java | {
"resource": ""
} |
q21692 | JournalSegment.unmap | train | private void unmap() {
if (storageLevel == StorageLevel.MAPPED) {
writer.unmap();
readers.forEach(reader -> reader.unmap());
}
} | java | {
"resource": ""
} |
q21693 | JournalSegment.createReader | train | MappableJournalSegmentReader<E> createReader() {
checkOpen();
MappableJournalSegmentReader<E> reader = new MappableJournalSegmentReader<>(
openChannel(file.file()), this, maxEntrySize, index, namespace);
MappedByteBuffer buffer = writer.buffer();
if (buffer != null) {
reader.map(buffer);
... | java | {
"resource": ""
} |
q21694 | JournalSegment.close | train | @Override
public void close() {
unmap();
writer.close();
readers.forEach(reader -> reader.close());
open = false;
} | java | {
"resource": ""
} |
q21695 | Futures.completedFutureAsync | train | public static <T> CompletableFuture<T> completedFutureAsync(T result, Executor executor) {
CompletableFuture<T> future = new CompletableFuture<>();
executor.execute(() -> future.complete(result));
return future;
} | java | {
"resource": ""
} |
q21696 | Futures.exceptionalFutureAsync | train | public static <T> CompletableFuture<T> exceptionalFutureAsync(Throwable t, Executor executor) {
CompletableFuture<T> future = new CompletableFuture<>();
executor.execute(() -> {
future.completeExceptionally(t);
});
return future;
} | java | {
"resource": ""
} |
q21697 | Futures.orderedFuture | train | public static <T> CompletableFuture<T> orderedFuture(CompletableFuture<T> future) {
CompletableFuture<T> newFuture = new OrderedFuture<>();
future.whenComplete((r, e) -> {
if (e == null) {
newFuture.complete(r);
} else {
newFuture.completeExceptionally(e);
}
});
return ... | java | {
"resource": ""
} |
q21698 | Futures.asyncFuture | train | public static <T> CompletableFuture<T> asyncFuture(CompletableFuture<T> future, Executor executor) {
CompletableFuture<T> newFuture = new AtomixFuture<>();
future.whenComplete((result, error) -> {
executor.execute(() -> {
if (error == null) {
newFuture.complete(result);
} else {
... | java | {
"resource": ""
} |
q21699 | Futures.allOf | train | public static <T> CompletableFuture<T> allOf(
List<CompletableFuture<T>> futures, BinaryOperator<T> reducer, T emptyValue) {
return allOf(futures).thenApply(resultList -> resultList.stream().reduce(reducer).orElse(emptyValue));
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.