Object readResolve() throws ObjectStreamException { return Segment.fromScopedName(value); } }
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])); }
public static Revision fromString(String scopedName) { String[] tokens = scopedName.split(":"); if (tokens.length == 3) { return new RevisionImpl(Segment.fromScopedName(tokens[0]), Long.parseLong(tokens[1]), Integer.parseInt(tokens[2])); } else { throw new SerializationException("Not a valid segment name: " + scopedName); } }
private void read00(RevisionDataInput revisionDataInput, PositionBuilder builder) throws IOException { Map<Segment, Long> map = revisionDataInput.readMap(in -> Segment.fromScopedName(in.readUTF()), RevisionDataInput::readCompactLong); builder.ownedSegments(map); }
@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 void invokeResendCallBack(WireCommand wireCommand) { if (state.needSuccessors.compareAndSet(false, true)) { Retry.indefinitelyWithExpBackoff(retrySchedule.getInitialMillis(), retrySchedule.getMultiplier(), retrySchedule.getMaxDelay(), t -> log.error(writerId + " to invoke resendToSuccessors callback: ", t)) .runInExecutor(() -> { log.debug("Invoking resendToSuccessors call back for {} on writer {}", wireCommand, writerId); resendToSuccessorsCallback.accept(Segment.fromScopedName(getSegmentName())); }, connectionFactory.getInternalExecutor()) .thenRun(() -> { log.trace("Release inflight latch for writer {}", writerId); state.waitingInflight.release(); }); } }
private void read00(RevisionDataInput in, SegmentCompletedBuilder builder) throws IOException { builder.readerId(in.readUTF()); builder.segmentCompleted(Segment.fromScopedName(in.readUTF())); builder.successorsMappedToTheirPredecessors(in.readMap(i -> Segment.fromScopedName(i.readUTF()), i -> i.readCollection(RevisionDataInput::readLong, ArrayList::new))); }
private void read00(RevisionDataInput in, AcquireSegmentBuilder builder) throws IOException { builder.readerId(in.readUTF()); builder.segment(Segment.fromScopedName(in.readUTF())); }
private void read00(RevisionDataInput in, RemoveReaderBuilder builder) throws IOException { builder.readerId(in.readUTF()); builder.ownedSegments(in.readMap(i -> Segment.fromScopedName(i.readUTF()), RevisionDataInput::readLong)); }
private void read00(RevisionDataInput revisionDataInput, ReaderGroupStateInitBuilder builder) throws IOException { builder.config(ReaderGroupConfig.fromBytes(ByteBuffer.wrap(revisionDataInput.readArray()))); ElementDeserializer<Segment> keyDeserializer = in -> Segment.fromScopedName(in.readUTF()); builder.segments(revisionDataInput.readMap(keyDeserializer, RevisionDataInput::readLong)); builder.endSegments(revisionDataInput.readMap(keyDeserializer, RevisionDataInput::readLong)); }
private void read00(RevisionDataInput revisionDataInput, EventPointerBuilder builder) throws IOException { builder.segment(Segment.fromScopedName(revisionDataInput.readUTF())); builder.eventStartOffset(revisionDataInput.readCompactLong()); builder.eventLength(revisionDataInput.readCompactInt()); }
private void read00(RevisionDataInput in, ReleaseSegmentBuilder builder) throws IOException { builder.readerId(in.readUTF()); builder.segment(Segment.fromScopedName(in.readUTF())); builder.offset(in.readLong()); }
private void read00(RevisionDataInput in, CheckpointReaderBuilder builder) throws IOException { builder.checkpointId(in.readUTF()); builder.readerId(in.readUTF()); builder.positions(in.readMap(i -> Segment.fromScopedName(i.readUTF()), RevisionDataInput::readLong)); }
@Test public void testSegment() { Segment segmnet = Segment.fromScopedName("foo/bar/2.#epoch.0"); assertEquals("foo/bar/2.#epoch.0", segmnet.getScopedName()); }
@Test public void testPosition() { PositionImpl pos = new PositionImpl(ImmutableMap.of(Segment.fromScopedName("foo/bar/1"), 2L)); ByteBuffer bytes = pos.toBytes(); Position pos2 = Position.fromBytes(bytes); assertEquals(pos, pos2); }
@Test public void testCheckpoint() { CheckpointImpl checkpoint = new CheckpointImpl("checkpoint", ImmutableMap.of(Segment.fromScopedName("Foo/Bar/1"), 3L)); ByteBuffer bytes = checkpoint.toBytes(); Checkpoint checkpoint2 = Checkpoint.fromBytes(bytes); assertEquals(checkpoint, checkpoint2); }
private void read00(RevisionDataInput revisionDataInput, CompactReaderGroupStateBuilder builder) throws IOException { ElementDeserializer<String> stringDeserializer = RevisionDataInput::readUTF; ElementDeserializer<Long> longDeserializer = RevisionDataInput::readLong; ElementDeserializer<Segment> segmentDeserializer = in -> Segment.fromScopedName(in.readUTF()); builder.config(ReaderGroupConfig.fromBytes(ByteBuffer.wrap(revisionDataInput.readArray()))); builder.checkpointState(CheckpointState.fromBytes(ByteBuffer.wrap(revisionDataInput.readArray()))); builder.distanceToTail(revisionDataInput.readMap(stringDeserializer, longDeserializer)); builder.futureSegments(revisionDataInput.readMap(segmentDeserializer, in -> in.readCollection(RevisionDataInput::readLong, HashSet::new))); builder.assignedSegments(revisionDataInput.readMap(stringDeserializer, in -> in.readMap(segmentDeserializer, longDeserializer))); builder.unassignedSegments(revisionDataInput.readMap(segmentDeserializer, longDeserializer)); builder.endSegments(revisionDataInput.readMap(segmentDeserializer, longDeserializer)); }
private void read00(RevisionDataInput input, CheckpointStateBuilder builder) throws IOException { ElementDeserializer<String> stringDeserializer = RevisionDataInput::readUTF; ElementDeserializer<Long> longDeserializer = RevisionDataInput::readLong; ElementDeserializer<Segment> segmentDeserializer = in -> Segment.fromScopedName(in.readUTF()); builder.checkpoints(input.readCollection(stringDeserializer, ArrayList::new)); builder.uncheckpointedHosts(input.readMap(stringDeserializer, in -> in.readCollection(stringDeserializer, ArrayList::new))); builder.checkpointPositions(input.readMap(stringDeserializer, in -> in.readMap(segmentDeserializer, longDeserializer))); builder.lastCheckpointPosition(input.readMap(segmentDeserializer, longDeserializer)); }
@Test public void testStreamCut() { StreamCutImpl cut = new StreamCutImpl(Stream.of("Foo/Bar"), ImmutableMap.of(Segment.fromScopedName("Foo/Bar/1"), 3L)); ByteBuffer bytes = cut.toBytes(); StreamCut cut2 = StreamCut.fromBytes(bytes); assertEquals(cut, cut2); bytes = StreamCut.UNBOUNDED.toBytes(); assertEquals(StreamCut.UNBOUNDED, StreamCut.fromBytes(bytes)); assertNotEquals(cut, StreamCut.UNBOUNDED); }
@Test public void testEventPointer() { EventPointerImpl pointer = new EventPointerImpl(Segment.fromScopedName("foo/bar/1"), 1000L, 100); String string = pointer.toString(); ByteBuffer bytes = pointer.toBytes(); assertEquals(pointer, EventPointer.fromBytes(bytes)); assertEquals(pointer, EventPointerImpl.fromString(string)); }