_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q21700 | PrimaryBackupRole.execute | train | public CompletableFuture<ExecuteResponse> execute(ExecuteRequest request) {
logRequest(request);
return CompletableFuture.completedFuture(logResponse(ExecuteResponse.error()));
} | java | {
"resource": ""
} |
q21701 | RaftSessionListener.addEventListener | train | public void addEventListener(EventType eventType, Consumer<PrimitiveEvent> listener) {
executor.execute(() -> eventListeners.computeIfAbsent(eventType.canonicalize(), e -> Sets.newLinkedHashSet()).add(listener));
} | java | {
"resource": ""
} |
q21702 | RaftSessionListener.removeEventListener | train | public void removeEventListener(EventType eventType, Consumer<PrimitiveEvent> listener) {
executor.execute(() -> eventListeners.computeIfAbsent(eventType.canonicalize(), e -> Sets.newLinkedHashSet()).remove(listener));
} | java | {
"resource": ""
} |
q21703 | RaftSessionListener.close | train | public CompletableFuture<Void> close() {
protocol.unregisterPublishListener(state.getSessionId());
return CompletableFuture.completedFuture(null);
} | java | {
"resource": ""
} |
q21704 | Operations.findMethods | train | private static Map<Method, OperationId> findMethods(Class<?> type) {
Map<Method, OperationId> operations = new HashMap<>();
for (Method method : type.getDeclaredMethods()) {
OperationId operationId = getOperationId(method);
if (operationId != null) {
if (operations.values().stream().anyMatch... | java | {
"resource": ""
} |
q21705 | Operations.getOperationId | train | private static OperationId getOperationId(Method method) {
Command command = method.getAnnotation(Command.class);
if (command != null) {
String name = command.value().equals("") ? method.getName() : command.value();
return OperationId.from(name, OperationType.COMMAND);
}
Query query = method... | java | {
"resource": ""
} |
q21706 | NettyUnicastService.bind | train | private void bind(Bootstrap bootstrap, Iterator<String> ifaces, int port, CompletableFuture<Void> future) {
if (ifaces.hasNext()) {
String iface = ifaces.next();
bootstrap.bind(iface, port).addListener((ChannelFutureListener) f -> {
if (f.isSuccess()) {
log.info("UDP server listening f... | java | {
"resource": ""
} |
q21707 | DefaultClusterEventService.getSubscriberNodes | train | private Stream<MemberId> getSubscriberNodes(String topicName) {
InternalTopic topic = topics.get(topicName);
if (topic == null) {
return Stream.empty();
}
return topic.remoteSubscriptions().stream()
.filter(s -> !s.isTombstone())
.map(s -> s.memberId())
.distinct();
} | java | {
"resource": ""
} |
q21708 | DefaultClusterEventService.getNextMemberId | train | private MemberId getNextMemberId(String topicName) {
InternalTopic topic = topics.get(topicName);
if (topic == null) {
return null;
}
TopicIterator iterator = topic.iterator();
if (iterator.hasNext()) {
return iterator.next().memberId();
}
return null;
} | java | {
"resource": ""
} |
q21709 | DefaultClusterEventService.update | train | private void update(Collection<InternalSubscriptionInfo> subscriptions) {
for (InternalSubscriptionInfo subscription : subscriptions) {
InternalTopic topic = topics.computeIfAbsent(subscription.topic, InternalTopic::new);
InternalSubscriptionInfo matchingSubscription = topic.remoteSubscriptions().stream... | java | {
"resource": ""
} |
q21710 | DefaultClusterEventService.gossip | train | private void gossip() {
List<Member> members = membershipService.getMembers()
.stream()
.filter(node -> !localMemberId.equals(node.id()))
.filter(node -> node.isReachable())
.collect(Collectors.toList());
if (!members.isEmpty()) {
Collections.shuffle(members);
Member... | java | {
"resource": ""
} |
q21711 | DefaultClusterEventService.updateNodes | train | private CompletableFuture<Void> updateNodes() {
List<CompletableFuture<Void>> futures = membershipService.getMembers()
.stream()
.filter(node -> !localMemberId.equals(node.id()))
.map(this::updateNode)
.collect(Collectors.toList());
return CompletableFuture.allOf(futures.toArray(... | java | {
"resource": ""
} |
q21712 | DefaultClusterEventService.updateNode | train | private CompletableFuture<Void> updateNode(Member member) {
long updateTime = System.currentTimeMillis();
long lastUpdateTime = updateTimes.getOrDefault(member.id(), 0L);
Collection<InternalSubscriptionInfo> subscriptions = topics.values()
.stream()
.flatMap(t -> t.remoteSubscriptions().str... | java | {
"resource": ""
} |
q21713 | DefaultClusterEventService.purgeTombstones | train | private void purgeTombstones() {
long minTombstoneTime = membershipService.getMembers()
.stream()
.map(node -> updateTimes.getOrDefault(node.id(), 0L))
.reduce(Math::min)
.orElse(0L);
for (InternalTopic topic : topics.values()) {
topic.purgeTombstones(minTombstoneTime);
... | java | {
"resource": ""
} |
q21714 | Retries.retryable | train | public static <U, V> Function<U, V> retryable(Function<U, V> base,
Class<? extends Throwable> exceptionClass,
int maxRetries,
int maxDelayBetweenRetries) {
return new Retry... | java | {
"resource": ""
} |
q21715 | Retries.retryable | train | public static <V> Supplier<V> retryable(Supplier<V> base,
Class<? extends Throwable> exceptionClass,
int maxRetries,
int maxDelayBetweenRetries) {
return () -> new RetryingFunction<>(v -> ba... | java | {
"resource": ""
} |
q21716 | Retries.randomDelay | train | public static void randomDelay(int ms) {
try {
Thread.sleep(ThreadLocalRandom.current().nextInt(ms));
} catch (InterruptedException e) {
throw new RuntimeException("Interrupted", e);
}
} | java | {
"resource": ""
} |
q21717 | Retries.delay | train | public static void delay(int ms, int nanos) {
try {
Thread.sleep(ms, nanos);
} catch (InterruptedException e) {
throw new RuntimeException("Interrupted", e);
}
} | java | {
"resource": ""
} |
q21718 | DefaultDocumentTreeNode.addChild | train | public Versioned<V> addChild(String name, V newValue, long newVersion) {
DefaultDocumentTreeNode<V> child = (DefaultDocumentTreeNode<V>) children.get(name);
if (child != null) {
return child.value();
}
children.put(name, new DefaultDocumentTreeNode<>(
new DocumentPath(name, path()), newVal... | java | {
"resource": ""
} |
q21719 | DefaultDocumentTreeNode.update | train | public Versioned<V> update(V newValue, long newVersion) {
Versioned<V> previousValue = value;
value = new Versioned<>(newValue, newVersion);
return previousValue;
} | java | {
"resource": ""
} |
q21720 | SwimMembershipProtocol.checkFailures | train | private void checkFailures() {
for (SwimMember member : members.values()) {
if (member.getState() == State.SUSPECT && System.currentTimeMillis() - member.getUpdated() > config.getFailureTimeout().toMillis()) {
member.setState(State.DEAD);
members.remove(member.id());
randomMembers.remo... | java | {
"resource": ""
} |
q21721 | SwimMembershipProtocol.sync | train | private void sync() {
List<SwimMember> syncMembers = discoveryService.getNodes().stream()
.map(node -> new SwimMember(MemberId.from(node.id().id()), node.address()))
.filter(member -> !member.id().equals(localMember.id()))
.collect(Collectors.toList());
for (SwimMember member : syncMembe... | java | {
"resource": ""
} |
q21722 | SwimMembershipProtocol.sync | train | private void sync(ImmutableMember member) {
LOGGER.trace("{} - Synchronizing membership with {}", localMember.id(), member);
bootstrapService.getMessagingService().sendAndReceive(
member.address(), MEMBERSHIP_SYNC, SERIALIZER.encode(localMember.copy()), false, config.getProbeTimeout())
.whenComp... | java | {
"resource": ""
} |
q21723 | SwimMembershipProtocol.handleSync | train | private Collection<ImmutableMember> handleSync(ImmutableMember member) {
updateState(member);
return new ArrayList<>(members.values().stream().map(SwimMember::copy).collect(Collectors.toList()));
} | java | {
"resource": ""
} |
q21724 | SwimMembershipProtocol.probe | train | private void probe() {
// First get a sorted list of discovery service nodes that are not present in the SWIM members.
// This is necessary to ensure we attempt to probe all nodes that are provided by the discovery provider.
List<SwimMember> probeMembers = Lists.newArrayList(discoveryService.getNodes().stre... | java | {
"resource": ""
} |
q21725 | SwimMembershipProtocol.probe | train | private void probe(ImmutableMember member) {
LOGGER.trace("{} - Probing {}", localMember.id(), member);
bootstrapService.getMessagingService().sendAndReceive(
member.address(), MEMBERSHIP_PROBE, SERIALIZER.encode(Pair.of(localMember.copy(), member)), false, config.getProbeTimeout())
.whenComplet... | java | {
"resource": ""
} |
q21726 | SwimMembershipProtocol.handleProbe | train | private ImmutableMember handleProbe(Pair<ImmutableMember, ImmutableMember> members) {
ImmutableMember remoteMember = members.getLeft();
ImmutableMember localMember = members.getRight();
LOGGER.trace("{} - Received probe {} from {}", this.localMember.id(), localMember, remoteMember);
// If the probe in... | java | {
"resource": ""
} |
q21727 | SwimMembershipProtocol.requestProbes | train | private void requestProbes(ImmutableMember suspect) {
Collection<SwimMember> members = selectRandomMembers(config.getSuspectProbes() - 1, suspect);
if (!members.isEmpty()) {
AtomicInteger counter = new AtomicInteger();
AtomicBoolean succeeded = new AtomicBoolean();
for (SwimMember member : mem... | java | {
"resource": ""
} |
q21728 | SwimMembershipProtocol.failProbes | train | private void failProbes(ImmutableMember suspect) {
SwimMember swimMember = new SwimMember(suspect);
LOGGER.debug("{} - Failed all probes of {}", localMember.id(), swimMember);
swimMember.setState(State.SUSPECT);
if (updateState(swimMember.copy()) && config.isBroadcastUpdates()) {
broadcast(swimMem... | java | {
"resource": ""
} |
q21729 | SwimMembershipProtocol.requestProbe | train | private CompletableFuture<Boolean> requestProbe(SwimMember member, ImmutableMember suspect) {
LOGGER.debug("{} - Requesting probe of {} from {}", this.localMember.id(), suspect, member);
return bootstrapService.getMessagingService().sendAndReceive(
member.address(), MEMBERSHIP_PROBE_REQUEST, SERIALIZER.... | java | {
"resource": ""
} |
q21730 | SwimMembershipProtocol.selectRandomMembers | train | private Collection<SwimMember> selectRandomMembers(int count, ImmutableMember exclude) {
List<SwimMember> members = this.members.values().stream()
.filter(member -> !member.id().equals(localMember.id()) && !member.id().equals(exclude.id()))
.collect(Collectors.toList());
Collections.shuffle(memb... | java | {
"resource": ""
} |
q21731 | SwimMembershipProtocol.handleProbeRequest | train | private CompletableFuture<Boolean> handleProbeRequest(ImmutableMember member) {
CompletableFuture<Boolean> future = new CompletableFuture<>();
swimScheduler.execute(() -> {
LOGGER.trace("{} - Probing {}", localMember.id(), member);
bootstrapService.getMessagingService().sendAndReceive(
mem... | java | {
"resource": ""
} |
q21732 | SwimMembershipProtocol.broadcast | train | private void broadcast(ImmutableMember update) {
for (SwimMember member : members.values()) {
if (!localMember.id().equals(member.id())) {
unicast(member, update);
}
}
} | java | {
"resource": ""
} |
q21733 | SwimMembershipProtocol.unicast | train | private void unicast(SwimMember member, ImmutableMember update) {
bootstrapService.getUnicastService().unicast(
member.address(),
MEMBERSHIP_GOSSIP,
SERIALIZER.encode(Lists.newArrayList(update)));
} | java | {
"resource": ""
} |
q21734 | SwimMembershipProtocol.gossip | train | private void gossip() {
// Check suspect nodes for failure timeouts.
checkFailures();
// Check local metadata for changes.
checkMetadata();
// Copy and clear the list of pending updates.
if (!updates.isEmpty()) {
List<ImmutableMember> updates = Lists.newArrayList(this.updates.values());
... | java | {
"resource": ""
} |
q21735 | SwimMembershipProtocol.gossip | train | private void gossip(Collection<ImmutableMember> updates) {
// Get a list of available peers. If peers are available, randomize the peer list and select a subset of
// peers with which to gossip updates.
List<SwimMember> members = Lists.newArrayList(randomMembers);
if (!members.isEmpty()) {
Collect... | java | {
"resource": ""
} |
q21736 | SwimMembershipProtocol.gossip | train | private void gossip(SwimMember member, Collection<ImmutableMember> updates) {
LOGGER.trace("{} - Gossipping updates {} to {}", localMember.id(), updates, member);
bootstrapService.getUnicastService().unicast(
member.address(),
MEMBERSHIP_GOSSIP,
SERIALIZER.encode(updates));
} | java | {
"resource": ""
} |
q21737 | SwimMembershipProtocol.registerHandlers | train | private void registerHandlers() {
// Register TCP message handlers.
bootstrapService.getMessagingService().registerHandler(MEMBERSHIP_SYNC, syncHandler, swimScheduler);
bootstrapService.getMessagingService().registerHandler(MEMBERSHIP_PROBE, probeHandler, swimScheduler);
bootstrapService.getMessagingSer... | java | {
"resource": ""
} |
q21738 | SwimMembershipProtocol.unregisterHandlers | train | private void unregisterHandlers() {
// Unregister TCP message handlers.
bootstrapService.getMessagingService().unregisterHandler(MEMBERSHIP_SYNC);
bootstrapService.getMessagingService().unregisterHandler(MEMBERSHIP_PROBE);
bootstrapService.getMessagingService().unregisterHandler(MEMBERSHIP_PROBE_REQUEST... | java | {
"resource": ""
} |
q21739 | AtomicSemaphoreProxy.holderStatus | train | public CompletableFuture<Map<Long, Integer>> holderStatus() {
return getProxyClient().applyBy(name(), service -> service.holderStatus());
} | java | {
"resource": ""
} |
q21740 | LeaderAppender.recordHeartbeat | train | private void recordHeartbeat(RaftMemberContext member, long timestamp) {
raft.checkThread();
// Update the member's heartbeat time. This will be used when calculating the quorum heartbeat time.
member.setHeartbeatTime(timestamp);
member.setResponseTime(System.currentTimeMillis());
// Compute the q... | java | {
"resource": ""
} |
q21741 | LeaderAppender.failHeartbeat | train | private void failHeartbeat() {
raft.checkThread();
// Iterate through pending timestamped heartbeat futures and fail futures that have been pending longer
// than an election timeout.
long currentTimestamp = System.currentTimeMillis();
Iterator<TimestampedFuture<Long>> iterator = heartbeatFutures.i... | java | {
"resource": ""
} |
q21742 | LeaderAppender.completeCommits | train | private void completeCommits(long previousCommitIndex, long commitIndex) {
for (long i = previousCommitIndex + 1; i <= commitIndex; i++) {
CompletableFuture<Long> future = appendFutures.remove(i);
if (future != null) {
future.complete(i);
}
}
} | java | {
"resource": ""
} |
q21743 | RaftPartitionGroup.snapshot | train | public CompletableFuture<Void> snapshot() {
return Futures.allOf(config.getMembers().stream()
.map(MemberId::from)
.map(id -> communicationService.send(snapshotSubject, null, id, SNAPSHOT_TIMEOUT))
.collect(Collectors.toList()))
.thenApply(v -> null);
} | java | {
"resource": ""
} |
q21744 | RaftPartitionGroup.handleSnapshot | train | private CompletableFuture<Void> handleSnapshot() {
return Futures.allOf(partitions.values().stream()
.map(partition -> partition.snapshot())
.collect(Collectors.toList()))
.thenApply(v -> null);
} | java | {
"resource": ""
} |
q21745 | AbstractAtomicMultimapService.onChange | train | private void onChange(String key, byte[] oldValue, byte[] newValue) {
listeners.forEach(id -> getSession(id).accept(client -> client.onChange(key, oldValue, newValue)));
} | java | {
"resource": ""
} |
q21746 | PrimaryBackupServiceSessions.openSession | train | public void openSession(PrimaryBackupSession session) {
sessions.put(session.sessionId().id(), session);
listeners.forEach(l -> l.onOpen(session));
} | java | {
"resource": ""
} |
q21747 | PrimaryBackupServiceSessions.expireSession | train | public void expireSession(PrimaryBackupSession session) {
if (sessions.remove(session.sessionId().id()) != null) {
session.expire();
listeners.forEach(l -> l.onExpire(session));
}
} | java | {
"resource": ""
} |
q21748 | PrimaryBackupServiceSessions.closeSession | train | public void closeSession(PrimaryBackupSession session) {
if (sessions.remove(session.sessionId().id()) != null) {
session.close();
listeners.forEach(l -> l.onClose(session));
}
} | java | {
"resource": ""
} |
q21749 | SegmentedJournalReader.initialize | train | private void initialize(long index) {
currentSegment = journal.getSegment(index);
currentSegment.acquire();
currentReader = currentSegment.createReader();
long nextIndex = getNextIndex();
while (index > nextIndex && hasNext()) {
next();
nextIndex = getNextIndex();
}
} | java | {
"resource": ""
} |
q21750 | SegmentedJournalReader.rewind | train | private void rewind(long index) {
if (currentSegment.index() >= index) {
JournalSegment<E> segment = journal.getSegment(index - 1);
if (segment != null) {
currentReader.close();
currentSegment.release();
currentSegment = segment;
currentSegment.acquire();
currentR... | java | {
"resource": ""
} |
q21751 | OperationResult.succeeded | train | public static OperationResult succeeded(long index, long eventIndex, byte[] result) {
return new OperationResult(index, eventIndex, null, result);
} | java | {
"resource": ""
} |
q21752 | OperationResult.failed | train | public static OperationResult failed(long index, long eventIndex, Throwable error) {
return new OperationResult(index, eventIndex, error, null);
} | java | {
"resource": ""
} |
q21753 | Versioned.map | train | public synchronized <U> Versioned<U> map(Function<V, U> transformer) {
return new Versioned<>(value != null ? transformer.apply(value) : null, version, creationTime);
} | java | {
"resource": ""
} |
q21754 | Versioned.valueOrElse | train | public static <U> U valueOrElse(Versioned<U> versioned, U defaultValue) {
return versioned == null ? defaultValue : versioned.value();
} | java | {
"resource": ""
} |
q21755 | PrimaryBackupMessageContext.eventSubject | train | String eventSubject(long sessionId) {
if (prefix == null) {
return String.format("event-%d", sessionId);
} else {
return String.format("%s-event-%d", prefix, sessionId);
}
} | java | {
"resource": ""
} |
q21756 | PolymorphicTypeMapper.getConcreteClass | train | @SuppressWarnings("unchecked")
public Class<? extends TypedConfig<?>> getConcreteClass(AtomixRegistry registry, String typeName) {
ConfiguredType type = registry.getType(typeClass, typeName);
if (type == null) {
return null;
}
return (Class<? extends TypedConfig<?>>) type.newConfig().getClass();... | java | {
"resource": ""
} |
q21757 | PrimaryElectorService.scheduleRebalance | train | private void scheduleRebalance() {
if (rebalanceTimer != null) {
rebalanceTimer.cancel();
}
rebalanceTimer = getScheduler().schedule(REBALANCE_DURATION, this::rebalance);
} | java | {
"resource": ""
} |
q21758 | PrimaryElectorService.rebalance | train | private void rebalance() {
boolean rebalanced = false;
for (ElectionState election : elections.values()) {
// Count the total number of primaries for this election's primary.
int primaryCount = election.countPrimaries(election.primary);
// Find the registration with the fewest number of prima... | java | {
"resource": ""
} |
q21759 | SnapshotStore.getCurrentSnapshot | train | public Snapshot getCurrentSnapshot() {
Map.Entry<Long, Snapshot> entry = snapshots.lastEntry();
return entry != null ? entry.getValue() : null;
} | java | {
"resource": ""
} |
q21760 | SnapshotStore.loadSnapshots | train | private Collection<Snapshot> loadSnapshots() {
// Ensure log directories are created.
storage.directory().mkdirs();
List<Snapshot> snapshots = new ArrayList<>();
// Iterate through all files in the log directory.
for (File file : storage.directory().listFiles(File::isFile)) {
// If the file... | java | {
"resource": ""
} |
q21761 | SnapshotStore.newTemporarySnapshot | train | public Snapshot newTemporarySnapshot(long index, WallClockTimestamp timestamp) {
SnapshotDescriptor descriptor = SnapshotDescriptor.builder()
.withIndex(index)
.withTimestamp(timestamp.unixTimestamp())
.build();
return newSnapshot(descriptor, StorageLevel.MEMORY);
} | java | {
"resource": ""
} |
q21762 | RaftPartition.snapshot | train | public CompletableFuture<Void> snapshot() {
RaftPartitionServer server = this.server;
if (server != null) {
return server.snapshot();
}
return CompletableFuture.completedFuture(null);
} | java | {
"resource": ""
} |
q21763 | RaftPartition.open | train | CompletableFuture<Partition> open(PartitionMetadata metadata, PartitionManagementService managementService) {
this.partition = metadata;
this.client = createClient(managementService);
if (partition.members().contains(managementService.getMembershipService().getLocalMember().id())) {
server = createSer... | java | {
"resource": ""
} |
q21764 | RaftPartition.update | train | CompletableFuture<Void> update(PartitionMetadata metadata, PartitionManagementService managementService) {
if (server == null && metadata.members().contains(managementService.getMembershipService().getLocalMember().id())) {
server = createServer(managementService);
return server.join(metadata.members())... | java | {
"resource": ""
} |
q21765 | RaftPartition.close | train | CompletableFuture<Void> close() {
return closeClient()
.exceptionally(v -> null)
.thenCompose(v -> closeServer())
.exceptionally(v -> null);
} | java | {
"resource": ""
} |
q21766 | RaftPartition.createServer | train | protected RaftPartitionServer createServer(PartitionManagementService managementService) {
return new RaftPartitionServer(
this,
config,
managementService.getMembershipService().getLocalMember().id(),
managementService.getMembershipService(),
managementService.getMessagingSer... | java | {
"resource": ""
} |
q21767 | RaftPartition.createClient | train | private RaftPartitionClient createClient(PartitionManagementService managementService) {
return new RaftPartitionClient(
this,
managementService.getMembershipService().getLocalMember().id(),
new RaftClientCommunicator(
name(),
Serializer.using(RaftNamespaces.RAFT_PROT... | java | {
"resource": ""
} |
q21768 | RaftPartition.delete | train | public CompletableFuture<Void> delete() {
return server.stop().thenCompose(v -> client.stop()).thenRun(() -> {
if (server != null) {
server.delete();
}
});
} | java | {
"resource": ""
} |
q21769 | RaftSession.setCommandSequence | train | public void setCommandSequence(long sequence) {
// For each increment of the sequence number, trigger query callbacks that are dependent on the specific sequence.
for (long i = commandSequence + 1; i <= sequence; i++) {
commandSequence = i;
List<Runnable> queries = this.sequenceQueries.remove(comman... | java | {
"resource": ""
} |
q21770 | RaftSession.setLastApplied | train | public void setLastApplied(long index) {
// Query callbacks for this session are added to the indexQueries map to be executed once the required index
// for the query is reached. For each increment of the index, trigger query callbacks that are dependent
// on the specific index.
for (long i = lastAppli... | java | {
"resource": ""
} |
q21771 | RaftSession.registerSequenceQuery | train | public void registerSequenceQuery(long sequence, Runnable query) {
// Add a query to be run once the session's sequence number reaches the given sequence number.
List<Runnable> queries = this.sequenceQueries.computeIfAbsent(sequence, v -> new LinkedList<Runnable>());
queries.add(query);
} | java | {
"resource": ""
} |
q21772 | RaftSession.registerIndexQuery | train | public void registerIndexQuery(long index, Runnable query) {
// Add a query to be run once the session's index reaches the given index.
List<Runnable> queries = this.indexQueries.computeIfAbsent(index, v -> new LinkedList<>());
queries.add(query);
} | java | {
"resource": ""
} |
q21773 | RaftSession.clearCommands | train | public Collection<PendingCommand> clearCommands() {
Collection<PendingCommand> commands = Lists.newArrayList(pendingCommands.values());
pendingCommands.clear();
return commands;
} | java | {
"resource": ""
} |
q21774 | RaftSession.getLastCompleted | train | public long getLastCompleted() {
// If there are any queued events, return the index prior to the first event in the queue.
EventHolder event = events.peek();
if (event != null && event.eventIndex > completeIndex) {
return event.eventIndex - 1;
}
// If no events are queued, return the highest ... | java | {
"resource": ""
} |
q21775 | RaftSession.clearEvents | train | private void clearEvents(long index) {
if (index > completeIndex) {
EventHolder event = events.peek();
while (event != null && event.eventIndex <= index) {
events.remove();
completeIndex = event.eventIndex;
event = events.peek();
}
completeIndex = index;
}
} | java | {
"resource": ""
} |
q21776 | RaftSession.sendEvents | train | private void sendEvents(EventHolder event) {
// Only send events to the client if this server is the leader.
if (server.isLeader()) {
eventExecutor.execute(() -> {
PublishRequest request = PublishRequest.builder()
.withSession(sessionId().id())
.withEventIndex(event.eventIn... | java | {
"resource": ""
} |
q21777 | RaftSession.open | train | public void open() {
setState(State.OPEN);
protocol.registerResetListener(sessionId(), request -> resendEvents(request.index()), server.getServiceManager().executor());
} | java | {
"resource": ""
} |
q21778 | AbstractProxyClient.onStateChange | train | private synchronized void onStateChange(PartitionId partitionId, PrimitiveState state) {
states.put(partitionId, state);
switch (state) {
case CONNECTED:
if (this.state != PrimitiveState.CONNECTED && !states.containsValue(PrimitiveState.SUSPENDED) && !states.containsValue(PrimitiveState.CLOSED)) {... | java | {
"resource": ""
} |
q21779 | MapValue.isNewerThan | train | public boolean isNewerThan(MapValue other) {
if (other == null) {
return true;
}
return this.timestamp.isNewerThan(other.timestamp);
} | java | {
"resource": ""
} |
q21780 | OrderedFuture.orderedFuture | train | private CompletableFuture<T> orderedFuture() {
if (!complete) {
synchronized (orderedFutures) {
if (!complete) {
CompletableFuture<T> future = new CompletableFuture<>();
orderedFutures.add(future);
return future;
}
}
}
// Completed
if (error == ... | java | {
"resource": ""
} |
q21781 | OrderedFuture.complete | train | private void complete(T result, Throwable error) {
synchronized (orderedFutures) {
this.result = result;
this.error = error;
this.complete = true;
if (error == null) {
for (CompletableFuture<T> future : orderedFutures) {
future.complete(result);
}
} else {
... | java | {
"resource": ""
} |
q21782 | RaftSessionInvoker.invoke | train | public CompletableFuture<byte[]> invoke(PrimitiveOperation operation) {
CompletableFuture<byte[]> future = new CompletableFuture<>();
switch (operation.id().type()) {
case COMMAND:
context.execute(() -> invokeCommand(operation, future));
break;
case QUERY:
context.execute(() ... | java | {
"resource": ""
} |
q21783 | MemberSelectorManager.createSelector | train | public MemberSelector createSelector(CommunicationStrategy selectionStrategy) {
MemberSelector selector = new MemberSelector(leader, members, selectionStrategy, this);
selectors.add(selector);
return selector;
} | java | {
"resource": ""
} |
q21784 | MemberSelectorManager.resetAll | train | public void resetAll(MemberId leader, Collection<MemberId> members) {
MemberId oldLeader = this.leader;
this.leader = leader;
this.members = Lists.newLinkedList(members);
selectors.forEach(s -> s.reset(leader, this.members));
if (!Objects.equals(oldLeader, leader)) {
leaderChangeListeners.forE... | java | {
"resource": ""
} |
q21785 | AtomixFuture.wrap | train | public static <T> AtomixFuture<T> wrap(CompletableFuture<T> future) {
AtomixFuture<T> newFuture = new AtomixFuture<>();
future.whenComplete((result, error) -> {
if (error == null) {
newFuture.complete(result);
} else {
newFuture.completeExceptionally(error);
}
});
retur... | java | {
"resource": ""
} |
q21786 | AtomixFuture.completedFuture | train | public static <T> CompletableFuture<T> completedFuture(T result) {
CompletableFuture<T> future = new AtomixFuture<>();
future.complete(result);
return future;
} | java | {
"resource": ""
} |
q21787 | AtomixFuture.exceptionalFuture | train | public static <T> CompletableFuture<T> exceptionalFuture(Throwable t) {
CompletableFuture<T> future = new AtomixFuture<>();
future.completeExceptionally(t);
return future;
} | java | {
"resource": ""
} |
q21788 | ReferencePool.acquire | train | public T acquire() {
if (closed) {
throw new IllegalStateException("pool closed");
}
T reference = pool.poll();
if (reference == null) {
reference = factory.createReference(this);
}
reference.acquire();
return reference;
} | java | {
"resource": ""
} |
q21789 | DistributedLogSessionClient.sessionBuilder | train | public LogSession.Builder sessionBuilder() {
return new DistributedLogSession.Builder() {
@Override
public LogSession build() {
return new DistributedLogSession(
partitionId,
sessionIdProvider.get().join(),
clusterMembershipService,
protocol,
... | java | {
"resource": ""
} |
q21790 | AbstractBuffer.checkRead | train | protected int checkRead(int length) {
checkRead(position, length);
int previousPosition = this.position;
this.position = previousPosition + length;
return offset(previousPosition);
} | java | {
"resource": ""
} |
q21791 | AbstractBuffer.checkWrite | train | protected int checkWrite(int length) {
checkWrite(position, length);
int previousPosition = this.position;
this.position = previousPosition + length;
return offset(previousPosition);
} | java | {
"resource": ""
} |
q21792 | AbstractBuffer.calculateCapacity | train | private int calculateCapacity(int minimumCapacity) {
int newCapacity = Math.min(Math.max(capacity, 2), minimumCapacity);
while (newCapacity < Math.min(minimumCapacity, maxCapacity)) {
newCapacity <<= 1;
}
return Math.min(newCapacity, maxCapacity);
} | java | {
"resource": ""
} |
q21793 | AbstractAsyncPrimitive.connect | train | @SuppressWarnings("unchecked")
public CompletableFuture<A> connect() {
return registry.createPrimitive(name(), type())
.thenApply(v -> (A) this);
} | java | {
"resource": ""
} |
q21794 | MemberConfig.setProperties | train | public MemberConfig setProperties(Map<String, String> map) {
Properties properties = new Properties();
properties.putAll(map);
return setProperties(properties);
} | java | {
"resource": ""
} |
q21795 | FileChannelJournalSegmentWriter.isFull | train | public boolean isFull() {
return size() >= segment.descriptor().maxSegmentSize()
|| getNextIndex() - firstIndex >= segment.descriptor().maxEntries();
} | java | {
"resource": ""
} |
q21796 | FileChannelJournalSegmentWriter.zero | train | private ByteBuffer zero() {
memory.clear();
for (int i = 0; i < memory.limit(); i++) {
memory.put(i, (byte) 0);
}
return memory;
} | java | {
"resource": ""
} |
q21797 | AntiEntropyMapDelegate.bootstrap | train | private void bootstrap() {
List<MemberId> activePeers = bootstrapPeersSupplier.get();
if (activePeers.isEmpty()) {
return;
}
try {
requestBootstrapFromPeers(activePeers)
.get(DistributedPrimitive.DEFAULT_OPERATION_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
} catch (ExecutionExcept... | java | {
"resource": ""
} |
q21798 | AntiEntropyMapDelegate.requestBootstrapFromPeer | train | private CompletableFuture<Void> requestBootstrapFromPeer(MemberId peer) {
LOGGER.trace("Sending bootstrap request to {} for {}", peer, mapName);
return clusterCommunicator.<MemberId, Void>send(
bootstrapMessageSubject,
localMemberId,
serializer::encode,
serializer::decode,
... | java | {
"resource": ""
} |
q21799 | AuthCredentials.clearSecrets | train | public void clearSecrets() {
if (password != null) {
Arrays.fill(password, (byte) '\0');
password = null;
}
nativeCredentials = null;
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.