@VisibleForTesting public boolean validate(Set<String> segmentNames) { for (Segment s: positions.keySet()) { if (!segmentNames.contains(s.getScopedName())) { return false; } } return true; }
/** * Given a set of segments returns one to release. The one returned is arbitrary. */ private Segment findSegmentToRelease() { Set<Segment> segments = sync.getState().getSegments(readerId); return segments.stream() .max((s1, s2) -> Double.compare(hashHelper.hashToRange(s1.getScopedName()), hashHelper.hashToRange(s2.getScopedName()))) .orElse(null); }
@Override public SegmentOutputStream createOutputStreamForSegment(Segment segment, EventWriterConfig config, String delegationToken) { return new SegmentOutputStreamImpl(segment.getScopedName(), controller, cf, UUID.randomUUID(), Callbacks::doNothing, getRetryFromConfig(config), delegationToken); }
private void write00(AcquireSegment object, RevisionDataOutput out) throws IOException { out.writeUTF(object.readerId); out.writeUTF(object.segment.getScopedName()); } }
private CompletableFuture<SegmentAttributeUpdated> updatePropertyAsync(UUID attributeId, long expected, long value, String delegationToken) { long requestId = requestIdGenerator.get(); log.trace("Updating segment attribute: {}", attributeId); RawClient connection = getConnection(); return connection.sendRequest(requestId, new UpdateSegmentAttribute(requestId, segmentId.getScopedName(), attributeId, value, expected, delegationToken)) .thenApply(r -> transformReply(r, SegmentAttributeUpdated.class)); }
private CompletableFuture<StreamSegmentInfo> getStreamSegmentInfo(String delegationToken) { long requestId = requestIdGenerator.get(); log.debug("Getting segment info for segment: {}", segmentId); RawClient connection = getConnection(); return connection.sendRequest(requestId, new GetStreamSegmentInfo(requestId, segmentId.getScopedName(), delegationToken)) .thenApply(r -> transformReply(r, StreamSegmentInfo.class)); }
private CompletableFuture<SegmentTruncated> truncateSegmentAsync(Segment segment, long offset, String delegationToken) { long requestId = requestIdGenerator.get(); log.trace("Truncating segment: {}", segment); RawClient connection = getConnection(); return connection.sendRequest(requestId, new TruncateSegment(requestId, segment.getScopedName(), offset, delegationToken)) .thenApply(r -> transformReply(r, SegmentTruncated.class)); }
private void write00(SegmentCompleted object, RevisionDataOutput out) throws IOException { out.writeUTF(object.readerId); out.writeUTF(object.segmentCompleted.getScopedName()); out.writeMap(object.successorsMappedToTheirPredecessors, (o, segment) -> o.writeUTF(segment.getScopedName()), (o, predecessors) -> o.writeCollection(predecessors, RevisionDataOutput::writeLong)); } }
private void write00(RemoveReader object, RevisionDataOutput out) throws IOException { out.writeUTF(object.readerId); out.writeMap(object.ownedSegments, (o, segment) -> o.writeUTF(segment.getScopedName()), RevisionDataOutput::writeLong); } }
public RawClient(Controller controller, ConnectionFactory connectionFactory, Segment segmentId) { this.segmentId = segmentId; this.connection = controller.getEndpointForSegment(segmentId.getScopedName()) .thenCompose((PravegaNodeUri uri) -> connectionFactory.establishConnection(uri, responseProcessor)); Futures.exceptionListener(connection, e -> closeConnection(e)); }
private void write00(PositionImpl position, RevisionDataOutput revisionDataOutput) throws IOException { Map<Segment, Long> map = position.getOwnedSegmentsWithOffsets(); revisionDataOutput.writeMap(map, (out, s) -> out.writeUTF(s.getScopedName()), (out, offset) -> out.writeCompactLong(offset)); } }
private void write00(CheckpointReader object, RevisionDataOutput out) throws IOException { out.writeUTF(object.checkpointId); out.writeUTF(object.readerId); out.writeMap(object.positions, (o, segment) -> o.writeUTF(segment.getScopedName()), RevisionDataOutput::writeLong); } }
@Override public Void answer(InvocationOnMock invocation) throws Throwable { processor.get().process(new StreamSegmentInfo(3, segment.getScopedName(), true, false, false, 0, 123, 121)); return null; } }).when(connection2).sendAsync(Mockito.eq(getSegmentInfo2), Mockito.any(ClientConnection.CompletedCallback.class));
private void write00(EventPointerImpl pointer, RevisionDataOutput revisionDataOutput) throws IOException { revisionDataOutput.writeUTF(pointer.getSegment().getScopedName()); revisionDataOutput.writeCompactLong(pointer.eventStartOffset); revisionDataOutput.writeCompactInt(pointer.getEventLength()); } }
@Override public Void answer(InvocationOnMock invocation) throws Throwable { processor.process(new SegmentTruncated(1, segment.getScopedName())); return null; } }).when(connection).sendAsync(Mockito.eq(new WireCommands.TruncateSegment(1, segment.getScopedName(), 123L, "")),
@Override public Void answer(InvocationOnMock invocation) throws Throwable { processor.process(new StreamSegmentInfo(1, segment.getScopedName(), true, false, false, 0, 123, 121)); return null; } }).when(connection).sendAsync(Mockito.eq(new WireCommands.GetStreamSegmentInfo(1, segment.getScopedName(), "")),
private void write00(CheckpointState object, RevisionDataOutput output) throws IOException { ElementSerializer<String> stringSerializer = RevisionDataOutput::writeUTF; ElementSerializer<Long> longSerializer = RevisionDataOutput::writeLong; ElementSerializer<Segment> segmentSerializer = (out, segment) -> out.writeUTF(segment.getScopedName()); output.writeCollection(object.checkpoints, stringSerializer); output.writeMap(object.uncheckpointedHosts, stringSerializer, (out, hosts) -> out.writeCollection(hosts, stringSerializer)); output.writeMap(object.checkpointPositions, stringSerializer, (out, map) -> out.writeMap(map, segmentSerializer, longSerializer)); output.writeMap(object.lastCheckpointPosition, segmentSerializer, longSerializer); } }
@Override public Void answer(InvocationOnMock invocation) throws Throwable { ReplyProcessor processor = cf.getProcessor(endpoint); processor.process(new StreamSegmentInfo(2, segment.getScopedName(), true, false, false, 0, 123, 121)); return null; } }).when(connection).sendAsync(Mockito.eq(getSegmentInfo2), Mockito.any(ClientConnection.CompletedCallback.class));
@Override public Void answer(InvocationOnMock invocation) throws Throwable { ConditionalAppend argument = (ConditionalAppend) invocation.getArgument(0); ReplyProcessor processor = connectionFactory.getProcessor(location); processor.process(new WireCommands.SegmentIsSealed(argument.getEventNumber(), segment.getScopedName(), mockClientReplyStackTrace)); return null; } }).when(mock).sendAsync(any(ConditionalAppend.class), any(ClientConnection.CompletedCallback.class));
@Override public Void answer(InvocationOnMock invocation) throws Throwable { SetupAppend argument = (SetupAppend) invocation.getArgument(0); connectionFactory.getProcessor(location) .process(new AppendSetup(argument.getRequestId(), segment.getScopedName(), argument.getWriterId(), 0)); return null; } }).when(mock).sendAsync(any(SetupAppend.class), any(ClientConnection.CompletedCallback.class));