private SegmentInfo segmentToInfo(Segment s) { @Cleanup SegmentMetadataClient client = segmentMetadataClientFactory.createSegmentMetadataClient(s, latestDelegationToken.get()); return client.getSegmentInfo(); } }
private SegmentInfo segmentToInfo(Segment s) { String delegationToken; synchronized (this) { delegationToken = latestDelegationToken.get(); } @Cleanup SegmentMetadataClient client = segmentMetadataClientFactory.createSegmentMetadataClient(s, delegationToken); return client.getSegmentInfo(); }
@Override public ByteStreamWriter createByteStreamWriter(String streamName) { StreamSegments segments = Futures.getThrowingException(controller.getCurrentSegments(scope, streamName)); Preconditions.checkArgument(segments.getSegments().size() == 1, "Stream is configured with more than one segment"); Segment segment = segments.getSegments().iterator().next(); EventWriterConfig config = EventWriterConfig.builder().build(); String delegationToken = segments.getDelegationToken(); return new BufferedByteStreamWriterImpl(new ByteStreamWriterImpl(outputStreamFactory.createOutputStreamForSegment(segment, config, delegationToken), metaStreamFactory.createSegmentMetadataClient(segment, delegationToken))); }
private long getRemainingBytes(SegmentMetadataClientFactory metaFactory, StreamCut fromStreamCut, StreamCut toStreamCut) { long totalLength = 0; //fetch StreamSegmentSuccessors final CompletableFuture<StreamSegmentSuccessors> unread; final Map<Segment, Long> endPositions; if (toStreamCut.equals(StreamCut.UNBOUNDED)) { unread = controller.getSuccessors(fromStreamCut); endPositions = Collections.emptyMap(); } else { unread = controller.getSegments(fromStreamCut, toStreamCut); endPositions = toStreamCut.asImpl().getPositions(); } StreamSegmentSuccessors unreadVal = Futures.getAndHandleExceptions(unread, RuntimeException::new); //compute remaining bytes. for (Segment s : unreadVal.getSegments()) { if (endPositions.containsKey(s)) { totalLength += endPositions.get(s); } else { @Cleanup SegmentMetadataClient metadataClient = metaFactory.createSegmentMetadataClient(s, unreadVal.getDelegationToken()); totalLength += metadataClient.fetchCurrentSegmentLength(); } } for (long bytesRead : fromStreamCut.asImpl().getPositions().values()) { totalLength -= bytesRead; } log.debug("Remaining bytes from position: {} to position: {} is {}", fromStreamCut, toStreamCut, totalLength); return totalLength; }
private void handleSegmentTruncated(EventSegmentReader segmentReader) throws ReaderNotInReaderGroupException, TruncatedDataException { Segment segmentId = segmentReader.getSegmentId(); log.info("{} encountered truncation for segment {} ", this, segmentId); String delegationToken = groupState.getOrRefreshDelegationTokenFor(segmentId); @Cleanup SegmentMetadataClient metadataClient = metadataClientFactory.createSegmentMetadataClient(segmentId, delegationToken); try { long startingOffset = metadataClient.getSegmentInfo().getStartingOffset(); segmentReader.setOffset(startingOffset); } catch (NoSuchSegmentException e) { handleEndOfSegment(segmentReader, true); } throw new TruncatedDataException(); }
private ByteStreamReader createByteStreamReaders(Segment segment) { String delegationToken = Futures.getAndHandleExceptions(controller.getOrRefreshDelegationTokenFor(segment.getScope(), segment.getStream() .getStreamName()), RuntimeException::new); return new ByteStreamReaderImpl(inputStreamFactory.createInputStreamForSegment(segment, delegationToken), metaStreamFactory.createSegmentMetadataClient(segment, delegationToken)); }
@Override @SuppressWarnings("deprecation") public <T> RevisionedStreamClient<T> createRevisionedStreamClient(String streamName, Serializer<T> serializer, SynchronizerConfig config) { log.info("Creating revisioned stream client for stream: {} with synchronizer configuration: {}", streamName, config); Segment segment = new Segment(scope, streamName, 0); EventSegmentReader in = inFactory.createEventReaderForSegment(segment); // Segment sealed is not expected for Revisioned Stream Client. Consumer<Segment> segmentSealedCallBack = s -> { throw new IllegalStateException("RevisionedClient: Segmentsealed exception observed for segment:" + s); }; String delegationToken = Futures.getAndHandleExceptions(controller.getOrRefreshDelegationTokenFor(segment.getScope(), segment.getStreamName()), RuntimeException::new); SegmentOutputStream out = outFactory.createOutputStreamForSegment(segment, segmentSealedCallBack, config.getEventWriterConfig(), delegationToken); ConditionalOutputStream cond = condFactory.createConditionalOutputStream(segment, delegationToken, config.getEventWriterConfig()); SegmentMetadataClient meta = metaFactory.createSegmentMetadataClient(segment, delegationToken); return new RevisionedStreamClientImpl<>(segment, in, out, cond, meta, serializer); }
SegmentMetadataClient metadataClient = Mockito.mock(SegmentMetadataClient.class); EventSegmentReader segmentInputStream = Mockito.mock(EventSegmentReader.class); Mockito.when(segmentMetadataClientFactory.createSegmentMetadataClient(any(Segment.class), any())).thenReturn(metadataClient); Mockito.when(segmentInputStream.getSegmentId()).thenReturn(segment); Mockito.when(segInputStreamFactory.createEventReaderForSegment(any(Segment.class), anyLong())).thenReturn(segmentInputStream);
streamManager.getConnectionFactory()); Segment segment = new Segment(scope, streamName, 0); SegmentMetadataClient metadataClient = metadataClientFactory.createSegmentMetadataClient(segment, ""); assertEquals(0, metadataClient.getSegmentInfo().getStartingOffset()); long writeOffset = metadataClient.getSegmentInfo().getWriteOffset();