@Override public CompletableFuture<PravegaNodeUri> getEndpointForSegment(String qualifiedSegmentName) { Segment segment = Segment.fromScopedName(qualifiedSegmentName); return controller.getURI(ModelHelper.createSegmentId(segment.getScope(), segment.getStreamName(), segment.getSegmentId())).thenApply(ModelHelper::encode); }
private Map<Segment, Long> getOffsetMap(List<String> scopes, List<String> streams, long offset) { Map<Segment, Long> offsetMap = new HashMap<>(); scopes.forEach(scope -> streams.forEach(stream -> offsetMap.put(new Segment(scope, stream, 0), offset))); return offsetMap; }
@VisibleForTesting public boolean validate(Set<String> segmentNames) { for (Segment s: positions.keySet()) { if (!segmentNames.contains(s.getScopedName())) { return false; } } return true; }
@Override public CompletableFuture<Boolean> isSegmentOpen(Segment segment) { return controller.isSegmentValid(segment.getScope(), segment.getStreamName(), segment.getSegmentId()); }
public String getOrRefreshDelegationTokenFor(Segment segmentId) { return getAndHandleExceptions(controller.getOrRefreshDelegationTokenFor(segmentId.getScope(), segmentId.getStreamName()), RuntimeException::new); } }
@Override public long getSegmentId() { return segment.getSegmentId(); }
Object readResolve() throws ObjectStreamException { return Segment.fromScopedName(value); } }
@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); }
private EventSegmentReader getEventSegmentReader(Segment segment, long endOffset, int bufferSize) { String delegationToken = Futures.getAndHandleExceptions(controller.getOrRefreshDelegationTokenFor(segment.getScope(), segment.getStream() .getStreamName()), RuntimeException::new); AsyncSegmentInputStreamImpl async = new AsyncSegmentInputStreamImpl(controller, cf, segment, delegationToken); async.getConnection(); return getEventSegmentReader(async, 0, endOffset, bufferSize); }
String stream = "testStream"; int segmentId = 1; Segment segment = new Segment(scope, stream, segmentId); EventPointer pointer = new EventPointerImpl(segment, 10L, 10); EventPointer pointerRead = EventPointer.fromBytes(pointer.toBytes()); name.append("/"); name.append(stream); assertEquals(name.toString(), pointerRead.asImpl().getSegment().getScopedStreamName()); assertEquals(name.toString(), pointerRead.asImpl().getSegment().getScopedName());
@Override public String getScope() { return segment.getScope(); }
@Override public String getStreamName() { return segment.getStreamName(); }
@Test public void testSegment() { Segment segmnet = Segment.fromScopedName("foo/bar/2.#epoch.0"); assertEquals("foo/bar/2.#epoch.0", segmnet.getScopedName()); }
private StreamCut computeEndStreamCut(Stream stream, Map<Segment, Long> endSegments) { final Map<Segment, Long> toPositions = endSegments.entrySet().stream() .filter(e -> e.getKey().getStream().equals(stream)) .collect(Collectors.toMap(Entry::getKey, Entry::getValue)); return toPositions.isEmpty() ? StreamCut.UNBOUNDED : new StreamCutImpl(stream, toPositions); }
@Synchronized Set<String> getStreamNames() { Set<String> result = new HashSet<>(); for (Map<Segment, Long> segments : assignedSegments.values()) { for (Segment segment : segments.keySet()) { result.add(segment.getScopedStreamName()); } } for (Segment segment : unassignedSegments.keySet()) { result.add(segment.getScopedStreamName()); } return result; }
public List<PendingEvent> refreshSegmentEventWritersUponSealed(Segment sealedSegment, Consumer<Segment> segmentSealedCallback) { StreamSegmentsWithPredecessors successors = Futures.getAndHandleExceptions( controller.getSuccessors(sealedSegment), t -> { log.error("Error while fetching successors for segment: {}", sealedSegment, t); return null; }); if (successors == null) { // Stream is deleted, complete all pending writes exceptionally. log.error("Stream is deleted, all pending writes will be completed exceptionally"); removeAllWriters().forEach(event -> event.getAckFuture() .completeExceptionally(new NoSuchSegmentException(sealedSegment.toString()))); return Collections.emptyList(); } else { return updateSegmentsUponSealed(successors, sealedSegment, segmentSealedCallback); } }
/** * Decodes segment and returns an instance of SegmentId. * * @param segment The segment. * @return Instance of SegmentId. */ public static final SegmentId decode(final Segment segment) { Preconditions.checkNotNull(segment, "segment"); return createSegmentId(segment.getScope(), segment.getStreamName(), segment.getSegmentId()); }
public static final Map<Long, Long> toSegmentOffsetMap(final PositionInternal position) { Preconditions.checkNotNull(position, "position"); return position.getOwnedSegmentsWithOffsets() .entrySet() .stream() .map(e -> new SimpleEntry<>(e.getKey().getSegmentId(), e.getValue())) .collect(Collectors.toMap(Entry::getKey, Entry::getValue)); }
public static EventPointer fromString(String eventPointer) { int i = eventPointer.lastIndexOf(":"); Preconditions.checkArgument(i > 0, "Invalid event pointer: %s", eventPointer); String[] offset = eventPointer.substring(i + 1).split("-"); Preconditions.checkArgument(offset.length == 2, "Invalid event pointer: %s", eventPointer); return new EventPointerImpl(Segment.fromScopedName(eventPointer.substring(0, i)), Long.parseLong(offset[0]), Integer.parseInt(offset[1])); }
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)); }