_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q21500 | SnapshotDescriptor.copyTo | train | SnapshotDescriptor copyTo(Buffer buffer) {
this.buffer = buffer
.writeLong(index)
.writeLong(timestamp)
.writeInt(version)
.writeBoolean(locked)
.skip(BYTES - buffer.position())
.flush();
return this;
} | java | {
"resource": ""
} |
q21501 | RaftSessionManager.resetConnections | train | public void resetConnections(MemberId leader, Collection<MemberId> servers) {
selectorManager.resetAll(leader, servers);
} | java | {
"resource": ""
} |
q21502 | RaftSessionManager.openSession | train | public CompletableFuture<RaftSessionState> openSession(
String serviceName,
PrimitiveType primitiveType,
ServiceConfig config,
ReadConsistency readConsistency,
CommunicationStrategy communicationStrategy,
Duration minTimeout,
Duration maxTimeout) {
checkNotNull(serviceName,... | java | {
"resource": ""
} |
q21503 | RaftSessionManager.closeSession | train | public CompletableFuture<Void> closeSession(SessionId sessionId, boolean delete) {
RaftSessionState state = sessions.get(sessionId.id());
if (state == null) {
return Futures.exceptionalFuture(new RaftException.UnknownSession("Unknown session: " + sessionId));
}
log.debug("Closing session {}", ses... | java | {
"resource": ""
} |
q21504 | RaftSessionManager.resetAllIndexes | train | private synchronized void resetAllIndexes() {
Collection<RaftSessionState> sessions = Lists.newArrayList(this.sessions.values());
// If no sessions are open, skip the keep-alive.
if (sessions.isEmpty()) {
return;
}
// Allocate session IDs, command response sequence numbers, and event index a... | java | {
"resource": ""
} |
q21505 | RaftSessionManager.resetIndexes | train | CompletableFuture<Void> resetIndexes(SessionId sessionId) {
RaftSessionState sessionState = sessions.get(sessionId.id());
if (sessionState == null) {
return Futures.exceptionalFuture(new IllegalArgumentException("Unknown session: " + sessionId));
}
CompletableFuture<Void> future = new Completable... | java | {
"resource": ""
} |
q21506 | RaftSessionManager.handleHeartbeat | train | private CompletableFuture<HeartbeatResponse> handleHeartbeat(HeartbeatRequest request) {
log.trace("Received {}", request);
boolean newLeader = !Objects.equals(selectorManager.leader(), request.leader());
selectorManager.resetAll(request.leader(), request.members());
HeartbeatResponse response = Heartbe... | java | {
"resource": ""
} |
q21507 | RaftStorageConfig.getDirectory | train | public String getDirectory(String groupName) {
return directory != null ? directory : System.getProperty("atomix.data", DATA_PREFIX) + "/" + groupName;
} | java | {
"resource": ""
} |
q21508 | RaftSessionSequencer.completeResponses | train | private void completeResponses() {
// Iterate through queued responses and complete as many as possible.
ResponseCallback response = responseCallbacks.get(responseSequence + 1);
while (response != null) {
// If the response was completed, remove the response callback from the response queue,
// ... | java | {
"resource": ""
} |
q21509 | VectorClock.update | train | public void update(VectorTimestamp<T> timestamp) {
VectorTimestamp<T> currentTimestamp = vector.get(timestamp.identifier());
if (currentTimestamp == null || currentTimestamp.value() < timestamp.value()) {
vector.put(timestamp.identifier(), timestamp);
}
} | java | {
"resource": ""
} |
q21510 | VectorClock.update | train | public void update(VectorClock<T> clock) {
for (VectorTimestamp<T> timestamp : clock.vector.values()) {
update(timestamp);
}
} | java | {
"resource": ""
} |
q21511 | AbstractClientConnection.addReplyTime | train | private void addReplyTime(String type, long replyTime) {
DescriptiveStatistics samples = replySamples.get(type);
if (samples == null) {
samples = replySamples.computeIfAbsent(type, t -> new SynchronizedDescriptiveStatistics(WINDOW_SIZE));
}
samples.addValue(replyTime);
} | java | {
"resource": ""
} |
q21512 | AbstractClientConnection.getTimeoutMillis | train | private long getTimeoutMillis(String type, Duration timeout) {
return timeout != null ? timeout.toMillis() : computeTimeoutMillis(type);
} | java | {
"resource": ""
} |
q21513 | AbstractClientConnection.computeTimeoutMillis | train | private long computeTimeoutMillis(String type) {
DescriptiveStatistics samples = replySamples.get(type);
if (samples == null || samples.getN() < MIN_SAMPLES) {
return MAX_TIMEOUT_MILLIS;
}
return Math.min(Math.max((int) samples.getMax() * TIMEOUT_FACTOR, MIN_TIMEOUT_MILLIS), MAX_TIMEOUT_MILLIS);
... | java | {
"resource": ""
} |
q21514 | ComposableFuture.except | train | public CompletableFuture<T> except(Consumer<Throwable> consumer) {
return whenComplete((result, error) -> {
if (error != null) {
consumer.accept(error);
}
});
} | java | {
"resource": ""
} |
q21515 | ComposableFuture.exceptAsync | train | public CompletableFuture<T> exceptAsync(Consumer<Throwable> consumer) {
return whenCompleteAsync((result, error) -> {
if (error != null) {
consumer.accept(error);
}
});
} | java | {
"resource": ""
} |
q21516 | SnapshotFile.isSnapshotFile | train | public static boolean isSnapshotFile(File file) {
checkNotNull(file, "file cannot be null");
String fileName = file.getName();
// The file name should contain an extension separator.
if (fileName.lastIndexOf(EXTENSION_SEPARATOR) == -1) {
return false;
}
// The file name should end with t... | java | {
"resource": ""
} |
q21517 | SnapshotFile.isNumeric | train | private static boolean isNumeric(String value) {
for (char c : value.toCharArray()) {
if (!Character.isDigit(c)) {
return false;
}
}
return true;
} | java | {
"resource": ""
} |
q21518 | SnapshotFile.createSnapshotFileName | train | @VisibleForTesting
static String createSnapshotFileName(String serverName, long index) {
return String.format("%s-%d.%s",
serverName,
index,
EXTENSION);
} | java | {
"resource": ""
} |
q21519 | MappableJournalSegmentWriter.map | train | MappedByteBuffer map() {
if (writer instanceof MappedJournalSegmentWriter) {
return ((MappedJournalSegmentWriter<E>) writer).buffer();
}
try {
JournalWriter<E> writer = this.writer;
MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, segment.descriptor().maxSegmentSiz... | java | {
"resource": ""
} |
q21520 | MappableJournalSegmentWriter.unmap | train | void unmap() {
if (writer instanceof MappedJournalSegmentWriter) {
JournalWriter<E> writer = this.writer;
this.writer = new FileChannelJournalSegmentWriter<>(channel, segment, maxEntrySize, index, namespace);
writer.close();
}
} | java | {
"resource": ""
} |
q21521 | SwimMembershipProtocolConfig.setProbeInterval | train | public SwimMembershipProtocolConfig setProbeInterval(Duration probeInterval) {
checkNotNull(probeInterval, "probeInterval cannot be null");
checkArgument(!probeInterval.isNegative() && !probeInterval.isZero(), "probeInterval must be positive");
this.probeInterval = probeInterval;
return this;
} | java | {
"resource": ""
} |
q21522 | SwimMembershipProtocolConfig.setProbeTimeout | train | public SwimMembershipProtocolConfig setProbeTimeout(Duration probeTimeout) {
checkNotNull(probeTimeout, "probeTimeout cannot be null");
checkArgument(!probeTimeout.isNegative() && !probeTimeout.isZero(), "probeTimeout must be positive");
this.probeTimeout = probeTimeout;
return this;
} | java | {
"resource": ""
} |
q21523 | SwimMembershipProtocolConfig.setFailureTimeout | train | public SwimMembershipProtocolConfig setFailureTimeout(Duration failureTimeout) {
checkNotNull(failureTimeout, "failureTimeout cannot be null");
checkArgument(!failureTimeout.isNegative() && !failureTimeout.isZero(), "failureTimeout must be positive");
this.failureTimeout = checkNotNull(failureTimeout);
... | java | {
"resource": ""
} |
q21524 | RaftMessageContext.publishSubject | train | String publishSubject(long sessionId) {
if (prefix == null) {
return String.format("publish-%d", sessionId);
} else {
return String.format("%s-publish-%d", prefix, sessionId);
}
} | java | {
"resource": ""
} |
q21525 | RaftMessageContext.resetSubject | train | String resetSubject(long sessionId) {
if (prefix == null) {
return String.format("reset-%d", sessionId);
} else {
return String.format("%s-reset-%d", prefix, sessionId);
}
} | java | {
"resource": ""
} |
q21526 | SegmentedJournal.openReader | train | public SegmentedJournalReader<E> openReader(long index, SegmentedJournalReader.Mode mode) {
SegmentedJournalReader<E> reader = new SegmentedJournalReader<>(this, index, mode);
readers.add(reader);
return reader;
} | java | {
"resource": ""
} |
q21527 | SegmentedJournal.resetSegments | train | JournalSegment<E> resetSegments(long index) {
assertOpen();
// If the index already equals the first segment index, skip the reset.
JournalSegment<E> firstSegment = getFirstSegment();
if (index == firstSegment.index()) {
return firstSegment;
}
for (JournalSegment<E> segment : segments.va... | java | {
"resource": ""
} |
q21528 | SegmentedJournal.getNextSegment | train | JournalSegment<E> getNextSegment(long index) {
Map.Entry<Long, JournalSegment<E>> nextSegment = segments.higherEntry(index);
return nextSegment != null ? nextSegment.getValue() : null;
} | java | {
"resource": ""
} |
q21529 | SegmentedJournal.removeSegment | train | synchronized void removeSegment(JournalSegment segment) {
segments.remove(segment.index());
segment.close();
segment.delete();
resetCurrentSegment();
} | java | {
"resource": ""
} |
q21530 | SegmentedJournal.newSegment | train | protected JournalSegment<E> newSegment(JournalSegmentFile segmentFile, JournalSegmentDescriptor descriptor) {
return new JournalSegment<>(segmentFile, descriptor, storageLevel, maxEntrySize, indexDensity, namespace);
} | java | {
"resource": ""
} |
q21531 | SegmentedJournal.resetHead | train | void resetHead(long index) {
for (SegmentedJournalReader reader : readers) {
if (reader.getNextIndex() < index) {
reader.reset(index);
}
}
} | java | {
"resource": ""
} |
q21532 | SegmentedJournal.resetTail | train | void resetTail(long index) {
for (SegmentedJournalReader reader : readers) {
if (reader.getNextIndex() >= index) {
reader.reset(index);
}
}
} | java | {
"resource": ""
} |
q21533 | SegmentedJournal.isCompactable | train | public boolean isCompactable(long index) {
Map.Entry<Long, JournalSegment<E>> segmentEntry = segments.floorEntry(index);
return segmentEntry != null && segments.headMap(segmentEntry.getValue().index()).size() > 0;
} | java | {
"resource": ""
} |
q21534 | SegmentedJournal.getCompactableIndex | train | public long getCompactableIndex(long index) {
Map.Entry<Long, JournalSegment<E>> segmentEntry = segments.floorEntry(index);
return segmentEntry != null ? segmentEntry.getValue().index() : 0;
} | java | {
"resource": ""
} |
q21535 | PhiAccrualFailureDetector.report | train | public void report(long arrivalTime) {
checkArgument(arrivalTime >= 0, "arrivalTime must not be negative");
long latestHeartbeat = history.latestHeartbeatTime();
history.samples().addValue(arrivalTime - latestHeartbeat);
history.setLatestHeartbeatTime(arrivalTime);
} | java | {
"resource": ""
} |
q21536 | PhiAccrualFailureDetector.phi | train | public double phi() {
long latestHeartbeat = history.latestHeartbeatTime();
DescriptiveStatistics samples = history.samples();
if (samples.getN() < minSamples) {
return 0.0;
}
return computePhi(samples, latestHeartbeat, System.currentTimeMillis());
} | java | {
"resource": ""
} |
q21537 | HandlerRegistry.register | train | void register(String type, BiConsumer<ProtocolRequest, ServerConnection> handler) {
handlers.put(type, handler);
} | java | {
"resource": ""
} |
q21538 | CoreTransactionService.onMembershipChange | train | private void onMembershipChange(ClusterMembershipEvent event) {
if (event.type() == ClusterMembershipEvent.Type.MEMBER_REMOVED) {
recoverTransactions(transactions.entrySet().iterator(), event.subject().id());
}
} | java | {
"resource": ""
} |
q21539 | CoreTransactionService.recoverTransactions | train | private void recoverTransactions(AsyncIterator<Map.Entry<TransactionId, Versioned<TransactionInfo>>> iterator, MemberId memberId) {
iterator.next().thenAccept(entry -> {
if (entry.getValue().value().coordinator.equals(memberId)) {
recoverTransaction(entry.getKey(), entry.getValue().value());
}
... | java | {
"resource": ""
} |
q21540 | CoreTransactionService.recoverTransaction | train | private void recoverTransaction(TransactionId transactionId, TransactionInfo transactionInfo) {
switch (transactionInfo.state) {
case PREPARING:
completePreparingTransaction(transactionId);
break;
case COMMITTING:
completeCommittingTransaction(transactionId);
break;
... | java | {
"resource": ""
} |
q21541 | CoreTransactionService.completeTransaction | train | @SuppressWarnings("unchecked")
private CompletableFuture<Void> completeTransaction(
TransactionId transactionId,
TransactionState expectState,
Function<TransactionInfo, TransactionInfo> updateFunction,
Predicate<TransactionInfo> updatedPredicate,
BiFunction<TransactionId, Transactional<?... | java | {
"resource": ""
} |
q21542 | DocumentTreeResource.getDocumentPath | train | private DocumentPath getDocumentPath(List<PathSegment> params) {
if (params.isEmpty()) {
return DocumentPath.ROOT;
} else {
return DocumentPath.from(params.stream().map(PathSegment::getPath).collect(Collectors.toList()));
}
} | java | {
"resource": ""
} |
q21543 | HeapBytes.allocate | train | public static HeapBytes allocate(int size) {
if (size > MAX_SIZE) {
throw new IllegalArgumentException("size cannot for HeapBytes cannot be greater than " + MAX_SIZE);
}
return new HeapBytes(ByteBuffer.allocate((int) size));
} | java | {
"resource": ""
} |
q21544 | MetaStore.loadVote | train | public synchronized MemberId loadVote() {
String id = metadataBuffer.readString(8);
return id != null ? MemberId.from(id) : null;
} | java | {
"resource": ""
} |
q21545 | EventLog.nextEvent | train | public CompletableFuture<E> nextEvent() {
E event = events.poll();
if (event != null) {
return CompletableFuture.completedFuture(event);
} else {
CompletableFuture<E> future = new CompletableFuture<>();
futures.add(future);
return future;
}
} | java | {
"resource": ""
} |
q21546 | EventLog.addEvent | train | public void addEvent(E event) {
CompletableFuture<E> future = futures.poll();
if (future != null) {
future.complete(event);
} else {
events.add(event);
if (events.size() > 100) {
events.remove();
}
}
} | java | {
"resource": ""
} |
q21547 | MappedMemory.allocate | train | public static MappedMemory allocate(File file, FileChannel.MapMode mode, int size) {
if (size > MAX_SIZE) {
throw new IllegalArgumentException("size cannot be greater than " + MAX_SIZE);
}
return new MappedMemoryAllocator(file, mode).allocate(size);
} | java | {
"resource": ""
} |
q21548 | LeaderElectionResource.getEventLogName | train | private String getEventLogName(String name, String id) {
return String.format("%s-%s", name, id);
} | java | {
"resource": ""
} |
q21549 | LeaderElectionResource.consumeNextEvent | train | private void consumeNextEvent(
EventLog<LeadershipEventListener<String>, LeadershipEvent<String>> eventLog,
String name,
String id,
AsyncResponse response) {
eventLog.nextEvent().whenComplete((event, error) -> {
if (error == null) {
if (event.newLeadership().leader() != null &&... | java | {
"resource": ""
} |
q21550 | DefaultRaftMetadataClient.getMetadata | train | private CompletableFuture<MetadataResponse> getMetadata() {
CompletableFuture<MetadataResponse> future = new CompletableFuture<>();
connection.metadata(MetadataRequest.builder().build()).whenComplete((response, error) -> {
if (error == null) {
if (response.status() == RaftResponse.Status.OK) {
... | java | {
"resource": ""
} |
q21551 | DefaultClusterMembershipService.handleMembershipEvent | train | private void handleMembershipEvent(GroupMembershipEvent event) {
post(new ClusterMembershipEvent(ClusterMembershipEvent.Type.valueOf(event.type().name()), event.member()));
} | java | {
"resource": ""
} |
q21552 | AtomixCluster.builder | train | public static AtomixClusterBuilder builder(String config, ClassLoader classLoader) {
return new AtomixClusterBuilder(config(withDefaultResources(config), classLoader));
} | java | {
"resource": ""
} |
q21553 | AtomixCluster.loadConfig | train | private static ClusterConfig loadConfig(File config, ClassLoader classLoader) {
return new ConfigMapper(classLoader).loadResources(ClusterConfig.class, config.getAbsolutePath());
} | java | {
"resource": ""
} |
q21554 | AtomixCluster.buildMessagingService | train | protected static ManagedMessagingService buildMessagingService(ClusterConfig config) {
return new NettyMessagingService(
config.getClusterId(),
config.getNodeConfig().getAddress(),
config.getMessagingConfig());
} | java | {
"resource": ""
} |
q21555 | AtomixCluster.buildUnicastService | train | protected static ManagedUnicastService buildUnicastService(ClusterConfig config) {
return new NettyUnicastService(config.getNodeConfig().getAddress(), config.getMessagingConfig());
} | java | {
"resource": ""
} |
q21556 | AtomixCluster.buildBroadcastService | train | protected static ManagedBroadcastService buildBroadcastService(ClusterConfig config) {
return NettyBroadcastService.builder()
.withLocalAddress(config.getNodeConfig().getAddress())
.withGroupAddress(new Address(
config.getMulticastConfig().getGroup().getHostAddress(),
config.... | java | {
"resource": ""
} |
q21557 | AtomixCluster.buildLocationProvider | train | @SuppressWarnings("unchecked")
protected static NodeDiscoveryProvider buildLocationProvider(ClusterConfig config) {
NodeDiscoveryConfig discoveryProviderConfig = config.getDiscoveryConfig();
if (discoveryProviderConfig != null) {
return discoveryProviderConfig.getType().newProvider(discoveryProviderConf... | java | {
"resource": ""
} |
q21558 | AtomixCluster.buildMembershipProtocol | train | @SuppressWarnings("unchecked")
protected static GroupMembershipProtocol buildMembershipProtocol(ClusterConfig config) {
return config.getProtocolConfig().getType().newProtocol(config.getProtocolConfig());
} | java | {
"resource": ""
} |
q21559 | AtomixCluster.buildClusterMembershipService | train | protected static ManagedClusterMembershipService buildClusterMembershipService(
ClusterConfig config,
BootstrapService bootstrapService,
NodeDiscoveryProvider discoveryProvider,
GroupMembershipProtocol membershipProtocol,
Version version) {
// If the local node has not be configured, c... | java | {
"resource": ""
} |
q21560 | AtomixCluster.buildClusterMessagingService | train | protected static ManagedClusterCommunicationService buildClusterMessagingService(
ClusterMembershipService membershipService, MessagingService messagingService, UnicastService unicastService) {
return new DefaultClusterCommunicationService(membershipService, messagingService, unicastService);
} | java | {
"resource": ""
} |
q21561 | PrimaryBackupServiceContext.open | train | public CompletableFuture<Void> open() {
return primaryElection.getTerm()
.thenAccept(this::changeRole)
.thenRun(() -> service.init(this));
} | java | {
"resource": ""
} |
q21562 | PrimaryBackupServiceContext.setTimestamp | train | public long setTimestamp(long timestamp) {
this.currentTimestamp = timestamp;
service.tick(WallClockTimestamp.from(timestamp));
return currentTimestamp;
} | java | {
"resource": ""
} |
q21563 | PrimaryBackupServiceContext.nextIndex | train | public boolean nextIndex(long index) {
if (operationIndex + 1 == index) {
currentOperation = OperationType.COMMAND;
operationIndex++;
return true;
}
return false;
} | java | {
"resource": ""
} |
q21564 | PrimaryBackupServiceContext.resetIndex | train | public void resetIndex(long index, long timestamp) {
currentOperation = OperationType.COMMAND;
operationIndex = index;
currentIndex = index;
currentTimestamp = timestamp;
setCommitIndex(index);
service.tick(new WallClockTimestamp(currentTimestamp));
} | java | {
"resource": ""
} |
q21565 | PrimaryBackupServiceContext.createSession | train | public PrimaryBackupSession createSession(long sessionId, MemberId memberId) {
PrimaryBackupSession session = new PrimaryBackupSession(SessionId.from(sessionId), memberId, service.serializer(), this);
if (sessions.putIfAbsent(sessionId, session) == null) {
service.register(session);
}
return sessi... | java | {
"resource": ""
} |
q21566 | PrimaryBackupServiceContext.getOrCreateSession | train | public PrimaryBackupSession getOrCreateSession(long sessionId, MemberId memberId) {
PrimaryBackupSession session = sessions.get(sessionId);
if (session == null) {
session = createSession(sessionId, memberId);
}
return session;
} | java | {
"resource": ""
} |
q21567 | PrimaryBackupServiceContext.expireSession | train | public void expireSession(long sessionId) {
PrimaryBackupSession session = sessions.remove(sessionId);
if (session != null) {
log.debug("Expiring session {}", session.sessionId());
session.expire();
service.expire(session.sessionId());
}
} | java | {
"resource": ""
} |
q21568 | PrimaryBackupServiceContext.closeSession | train | public void closeSession(long sessionId) {
PrimaryBackupSession session = sessions.remove(sessionId);
if (session != null) {
log.debug("Closing session {}", session.sessionId());
session.close();
service.close(session.sessionId());
}
} | java | {
"resource": ""
} |
q21569 | PrimaryBackupServiceContext.close | train | public CompletableFuture<Void> close() {
CompletableFuture<Void> future = new CompletableFuture<>();
threadContext.execute(() -> {
try {
clusterMembershipService.removeListener(membershipEventListener);
primaryElection.removeListener(primaryElectionListener);
role.close();
} ... | java | {
"resource": ""
} |
q21570 | LogServerRole.consume | train | public CompletableFuture<ConsumeResponse> consume(ConsumeRequest request) {
logRequest(request);
return CompletableFuture.completedFuture(logResponse(ConsumeResponse.error()));
} | java | {
"resource": ""
} |
q21571 | DefaultPartitionGroupMembershipService.handleMembershipChange | train | private void handleMembershipChange(ClusterMembershipEvent event) {
if (event.type() == ClusterMembershipEvent.Type.MEMBER_ADDED) {
bootstrap(event.subject());
} else if (event.type() == ClusterMembershipEvent.Type.MEMBER_REMOVED) {
threadContext.execute(() -> {
PartitionGroupMembership syst... | java | {
"resource": ""
} |
q21572 | DefaultPartitionGroupMembershipService.bootstrap | train | private CompletableFuture<Void> bootstrap(int attempt, CompletableFuture<Void> future) {
Futures.allOf(membershipService.getMembers().stream()
.filter(node -> !node.id().equals(membershipService.getLocalMember().id()))
.map(node -> bootstrap(node))
.collect(Collectors.toList()))
.whe... | java | {
"resource": ""
} |
q21573 | DefaultPartitionGroupMembershipService.bootstrap | train | @SuppressWarnings("unchecked")
private CompletableFuture<Void> bootstrap(Member member, CompletableFuture<Void> future) {
LOGGER.debug("{} - Bootstrapping from member {}", membershipService.getLocalMember().id(), member);
messagingService.<PartitionGroupInfo, PartitionGroupInfo>send(
BOOTSTRAP_SUBJECT... | java | {
"resource": ""
} |
q21574 | PrimaryBackupPartition.join | train | CompletableFuture<Partition> join(
PartitionManagementService managementService,
ThreadContextFactory threadFactory) {
election = managementService.getElectionService().getElectionFor(partitionId);
server = new PrimaryBackupPartitionServer(
this,
managementService,
memberGrou... | java | {
"resource": ""
} |
q21575 | PrimaryBackupPartition.connect | train | CompletableFuture<Partition> connect(
PartitionManagementService managementService,
ThreadContextFactory threadFactory) {
election = managementService.getElectionService().getElectionFor(partitionId);
client = new PrimaryBackupPartitionClient(this, managementService, threadFactory);
return clien... | java | {
"resource": ""
} |
q21576 | PrimaryBackupPartition.close | train | public CompletableFuture<Void> close() {
if (client == null) {
return CompletableFuture.completedFuture(null);
}
CompletableFuture<Void> future = new CompletableFuture<>();
client.stop().whenComplete((clientResult, clientError) -> {
if (server != null) {
server.stop().whenComplete((... | java | {
"resource": ""
} |
q21577 | PolymorphicConfigMapper.isPolymorphicType | train | private boolean isPolymorphicType(Class<?> clazz) {
return polymorphicTypes.stream().anyMatch(polymorphicType -> polymorphicType.getConfigClass() == clazz);
} | java | {
"resource": ""
} |
q21578 | Events.findMethods | train | private static Map<Method, EventType> findMethods(Class<?> type) {
Map<Method, EventType> events = new HashMap<>();
for (Method method : type.getDeclaredMethods()) {
Event event = method.getAnnotation(Event.class);
if (event != null) {
String name = event.value().equals("") ? method.getName(... | java | {
"resource": ""
} |
q21579 | SerializerBuilder.addSerializer | train | public SerializerBuilder addSerializer(com.esotericsoftware.kryo.Serializer serializer, Class<?>... types) {
namespaceBuilder.register(serializer, types);
return this;
} | java | {
"resource": ""
} |
q21580 | RaftSessionConnection.reset | train | public void reset(MemberId leader, Collection<MemberId> servers) {
selector.reset(leader, servers);
} | java | {
"resource": ""
} |
q21581 | RaftSessionConnection.openSession | train | public CompletableFuture<OpenSessionResponse> openSession(OpenSessionRequest request) {
CompletableFuture<OpenSessionResponse> future = new CompletableFuture<>();
if (context.isCurrentContext()) {
sendRequest(request, protocol::openSession, future);
} else {
context.execute(() -> sendRequest(req... | java | {
"resource": ""
} |
q21582 | RaftSessionConnection.closeSession | train | public CompletableFuture<CloseSessionResponse> closeSession(CloseSessionRequest request) {
CompletableFuture<CloseSessionResponse> future = new CompletableFuture<>();
if (context.isCurrentContext()) {
sendRequest(request, protocol::closeSession, future);
} else {
context.execute(() -> sendReques... | java | {
"resource": ""
} |
q21583 | RaftSessionConnection.keepAlive | train | public CompletableFuture<KeepAliveResponse> keepAlive(KeepAliveRequest request) {
CompletableFuture<KeepAliveResponse> future = new CompletableFuture<>();
if (context.isCurrentContext()) {
sendRequest(request, protocol::keepAlive, future);
} else {
context.execute(() -> sendRequest(request, prot... | java | {
"resource": ""
} |
q21584 | RaftSessionConnection.query | train | public CompletableFuture<QueryResponse> query(QueryRequest request) {
CompletableFuture<QueryResponse> future = new CompletableFuture<>();
if (context.isCurrentContext()) {
sendRequest(request, protocol::query, future);
} else {
context.execute(() -> sendRequest(request, protocol::query, future)... | java | {
"resource": ""
} |
q21585 | RaftSessionConnection.command | train | public CompletableFuture<CommandResponse> command(CommandRequest request) {
CompletableFuture<CommandResponse> future = new CompletableFuture<>();
if (context.isCurrentContext()) {
sendRequest(request, protocol::command, future);
} else {
context.execute(() -> sendRequest(request, protocol::comm... | java | {
"resource": ""
} |
q21586 | RaftSessionConnection.metadata | train | public CompletableFuture<MetadataResponse> metadata(MetadataRequest request) {
CompletableFuture<MetadataResponse> future = new CompletableFuture<>();
if (context.isCurrentContext()) {
sendRequest(request, protocol::metadata, future);
} else {
context.execute(() -> sendRequest(request, protocol:... | java | {
"resource": ""
} |
q21587 | MappedBytes.delete | train | public void delete() {
try {
close();
Files.delete(file.toPath());
} catch (IOException e) {
throw new RuntimeException(e);
}
} | java | {
"resource": ""
} |
q21588 | ProxyIterator.batch | train | private CompletableFuture<Iterator<T>> batch() {
return batch.thenCompose(iterator -> {
if (iterator != null && !iterator.hasNext()) {
batch = fetch(iterator.position());
return batch.thenApply(Function.identity());
}
return CompletableFuture.completedFuture(iterator);
});
} | java | {
"resource": ""
} |
q21589 | ProxyIterator.fetch | train | private CompletableFuture<IteratorBatch<T>> fetch(int position) {
return openFuture.thenCompose(initialBatch -> {
if (!initialBatch.complete()) {
return client.applyOn(partitionId, service -> nextFunction.next(service, initialBatch.id(), position))
.thenCompose(nextBatch -> {
... | java | {
"resource": ""
} |
q21590 | MulticastConfig.setGroup | train | public MulticastConfig setGroup(String group) {
try {
InetAddress address = InetAddress.getByName(group);
if (!address.isMulticastAddress()) {
throw new ConfigurationException("Invalid multicast group " + group);
}
return setGroup(address);
} catch (UnknownHostException e) {
... | java | {
"resource": ""
} |
q21591 | AbstractAccumulator.rescheduleTask | train | private void rescheduleTask(AtomicReference<TimerTask> taskRef, long millis) {
ProcessorTask newTask = new ProcessorTask();
timer.schedule(newTask, millis);
swapAndCancelTask(taskRef, newTask);
} | java | {
"resource": ""
} |
q21592 | AbstractAccumulator.swapAndCancelTask | train | private void swapAndCancelTask(AtomicReference<TimerTask> taskRef,
TimerTask newTask) {
TimerTask oldTask = taskRef.getAndSet(newTask);
if (oldTask != null) {
oldTask.cancel();
}
} | java | {
"resource": ""
} |
q21593 | AbstractAccumulator.finalizeCurrentBatch | train | private List<T> finalizeCurrentBatch() {
List<T> finalizedList;
synchronized (items) {
finalizedList = ImmutableList.copyOf(items);
items.clear();
/*
* To avoid reprocessing being triggered on an empty list.
*/
cancelTask(maxTask);
cancelTask(idleTas... | java | {
"resource": ""
} |
q21594 | CrdtSetDelegate.set | train | protected Set<E> set() {
return elements.entrySet()
.stream()
.filter(entry -> !entry.getValue().isTombstone())
.map(entry -> decode(entry.getKey()))
.collect(Collectors.toSet());
} | java | {
"resource": ""
} |
q21595 | CrdtSetDelegate.encode | train | private String encode(Object element) {
return BaseEncoding.base16().encode(elementSerializer.encode(element));
} | java | {
"resource": ""
} |
q21596 | CrdtSetDelegate.decode | train | protected E decode(String element) {
return elementSerializer.decode(BaseEncoding.base16().decode(element));
} | java | {
"resource": ""
} |
q21597 | CrdtSetDelegate.updateElements | train | private void updateElements(Map<String, SetElement> elements) {
for (SetElement element : elements.values()) {
if (element.isTombstone()) {
if (remove(element)) {
eventListeners.forEach(listener -> listener.event(new SetDelegateEvent<>(SetDelegateEvent.Type.REMOVE, decode(element.value()))))... | java | {
"resource": ""
} |
q21598 | PrimaryBackupClient.sessionBuilder | train | public PrimaryBackupSessionClient.Builder sessionBuilder(String primitiveName, PrimitiveType primitiveType, ServiceConfig serviceConfig) {
byte[] configBytes = Serializer.using(primitiveType.namespace()).encode(serviceConfig);
return new PrimaryBackupSessionClient.Builder() {
@Override
public Sessio... | java | {
"resource": ""
} |
q21599 | PrimaryBackupClient.close | train | public CompletableFuture<Void> close() {
threadContext.close();
if (closeOnStop) {
threadContextFactory.close();
}
return CompletableFuture.completedFuture(null);
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.