@NotNull private TableStore<T> writeTableStore(MappedBytes bytes, Wire wire, StoreRecovery recovery) { TableStore<T> store = new SingleTableStore<>(wireType, bytes, recovery, metadata); wire.writeEventName("header").object(store); wire.updateFirstHeader(); return store; }
@Override public void writeMarshallable(@NotNull WireOut wire) { wire.write(IndexingFields.indexCount).int64(indexCount) .write(IndexingFields.indexSpacing).int64(indexSpacing) .write(IndexingFields.index2Index).int64forBinding(0L, index2Index) .write(IndexingFields.lastIndex).int64forBinding(0L, nextEntryToBeIndexed); }
@Override public long recoverAndWriteHeader(@NotNull Wire wire, long timeoutMS, final LongValue lastPosition, Sequence sequence) throws UnrecoverableTimeoutException { Bytes<?> bytes = wire.bytes(); long offset = bytes.writePosition(); int num = bytes.readVolatileInt(offset); final long targetHeaderNumber = wire.headerNumber() + 1; String msgStart = "Unable to write a header at header number: 0x" + Long.toHexString(targetHeaderNumber) + " position: " + offset; if (Wires.isNotComplete(num)) { long pos = bytes.writePosition(); try { bytes.writeSkip(4); final String debugMessage = "!! Skipped due to recovery of locked header !! By thread " + Thread.currentThread().getName() + ", pid " + OS.getProcessId(); wire.getValueOut().text(debugMessage); final StringWriter stackVisitor = new StringWriter(); new RuntimeException().printStackTrace(new PrintWriter(stackVisitor)); wire.getValueOut().text(stackTrace); wire.addPadding(Math.toIntExact(sizeToSkip + (pos + 4) - bytes.writePosition()));
private static WireOut intForBinding(ValueOut wireOut, final LongValue value) { return value instanceof TwoLongValue ? wireOut.int128forBinding(0L, 0L, (TwoLongValue) value) : wireOut.int64forBinding(0L, value); }
@Override public void writeMarshallable(@NotNull WireOut wire) { wire .write(MetaDataField.roll).typedMarshallable(roll) .write(MetaDataField.deltaCheckpointInterval).int32(this.deltaCheckpointInterval) .write(MetaDataField.sourceId).int32(this.sourceId); }
@NotNull public static WriteMarshallable newMapReplicationHandler(long lastUpdateTime, @NotNull Class keyType, @NotNull Class valueType, String csp, long cid) { @NotNull final MapReplicationHandler h = new MapReplicationHandler (lastUpdateTime, keyType, valueType); return w -> w.writeDocument(true, d -> d.writeEventName(CoreFields.csp).text(csp) .writeEventName(CoreFields.cid).int64(cid) .writeEventName(CoreFields.handler).typedMarshallable(h)); }
@NotNull final ValueIn valueIn = inWire.readEventName(eventName); outWire.writeDocument(true, wire -> outWire.writeEventName(CoreFields.tid).int64(tid)); outWire.writeEventName(reply).object(columnView.columns()); return; @Nullable ColumnViewInternal.SortedFilter filters = valueIn.object(ColumnViewInternal.SortedFilter.class); int count = columnView.rowCount(filters == null ? new ColumnViewInternal.SortedFilter() : filters); outWire.writeEventName(reply).int32(count); return; wire.read(changedRow.params()[1]).object(oldRow, Map.class); final int result = columnView.changedRow(newRow, oldRow); outWire.writeEventName(reply).int32(result); }); return; outWire.writeEventName(reply).bool(columnView.canDeleteRows()); return; @Nullable final List keys = valueIn.object(keysList, List.class); final boolean result = columnView.containsRowWithKey(keys); outWire.writeEventName(reply).bool(result); return;
@Override public void accept(@NotNull final WireIn inWire, Long inputTid) { @NotNull final ValueIn valueIn = inWire.readEventName(eventName); assert startEnforceInValueReadCheck(inWire); try { outWire.writeDocument(true, wire -> outWire.writeEventName(tid).int64(inputTid)); outWire.writeEventName(reply).int64(view.subscriberCount()); return; valueIn.marshallable(wire -> { @NotNull final Params[] params = update4.params(); @Nullable final SerializableBiFunction updater = (SerializableBiFunction) wire.read(params[0]).object(Object.class); @Nullable final Object updateArg = wire.read(params[1]).object(Object.class); @NotNull final SerializableBiFunction returnFunction = (SerializableBiFunction) wire.read(params[2]).object(Object.class); @Nullable final Object returnArg = wire.read(params[3]).object(Object.class); outWire.writeEventName(reply).object(view.syncUpdate(updater, updateArg, returnFunction, returnArg)); }); return; @Nullable final SerializableBiFunction function = (SerializableBiFunction) wire.read(params[0]).object(Object.class); @Nullable final Object arg = wire.read(params[1]).object(Object.class); outWire.writeEventName(reply).object(view.applyTo(function, arg)); });
@NotNull static SingleChronicleQueueStore createStore(@NotNull RollingChronicleQueue queue, @NotNull Wire wire) { final SingleChronicleQueueStore wireStore = new SingleChronicleQueueStore( queue.rollCycle(), queue.wireType(), (MappedBytes) wire.bytes(), queue.indexCount(), queue.indexSpacing()); wire.writeEventName(MetaDataKeys.header).typedMarshallable(wireStore); return wireStore; }
@Override public void writeMarshallable(@NotNull WireOut out) { out.write("timeStamp").int64forBinding(0); }
@Override public void writeMarshallable(@NotNull WireOut wire) { wire.write(RollFields.length).int32(length) .write(RollFields.format).text(format) .write(RollFields.epoch).int64(epoch); if (rollTime != null) wire.write(RollFields.rollTime).time(rollTime); if (rollTimeZone != null) wire.write(RollFields.rollTimeZone).text(rollTimeZone.getId()); }
@Override public void writeMarshallable(@NotNull WireOut wire) { wire .write(MetaDataField.wireType).object(wireType) .write(MetaDataField.recovery).typedMarshallable(recovery); if (metadata != Metadata.NoMeta.INSTANCE) wire.write(MetaDataField.metadata).typedMarshallable(this.metadata); // align to a word whether needed or not as a micro-optimisation. wire.writeAlignTo(Integer.BYTES, 0); }
@Override public void writeMarshallable(@NotNull WireOut wire) { wire.write("age").int32(age); // interrupt half way through writing if (INTERRUPT.equals(name)) { Thread.currentThread().interrupt(); } else if (THROW.equals(name)) { throw new NullPointerException(); } else { wire.write("name").text(name); } }
@Override public void writeMarshallable(@NotNull WireOut wire) { ValueOut wireOut = wire.write(MetaDataField.writePosition); intForBinding(wireOut, writePosition).write(MetaDataField.indexing).typedMarshallable(this.indexing); wire.padToCacheAlign(); }
@NotNull private Wire toWire(int key) { final MyData myData = new MyData(); myData.key = key; myData.value = Integer.toString(key); Wire result = WireType.BINARY.apply(Bytes.elasticByteBuffer()); try (final DocumentContext dc = result.writingDocument()) { dc.wire().getValueOut().typedMarshallable(myData); } return result; }
private void write(@NotNull ChronicleQueue aChronicle, int messages) { final ExcerptAppender myAppender = aChronicle.acquireAppender(); for (int myCount = 0; myCount < messages; myCount++) { myAppender.writeDocument(aMarshallable -> aMarshallable.write().bytes(Long.toString(currentTimeMillis()).getBytes(StandardCharsets.UTF_8))); // System.out.println(Long.toHexString(myAppender.lastIndexAppended())); } } }
public void appendMessage(@NotNull ChronicleQueue queue, long expectedIndex, String msg) { @NotNull ExcerptAppender appender = queue.acquireAppender(); switch (appendMode) { case 1: appender.writeDocument(w -> w.write(() -> "msg").text(msg)); break; case 2: Bytes bytes = Bytes.elasticByteBuffer(); new BinaryWire(bytes).write(() -> "msg").text(msg); appender.writeBytes(bytes); bytes.release(); break; default: try (DocumentContext dc = appender.writingDocument()) { Wire wire = dc.wire(); wire.write(() -> "msg").text(msg); } break; } long index = appender.lastIndexAppended(); assertHexEquals(expectedIndex, index); }
@Test public void testIncompleteHeader() throws FileNotFoundException { @NotNull File dir = new File(OS.TARGET, getClass().getSimpleName() + "-" + System.nanoTime()); dir.mkdir(); @NotNull MappedBytes bytes = MappedBytes.mappedBytes(new File(dir, "19700101" + SingleChronicleQueue.SUFFIX), ChronicleQueue.TEST_BLOCK_SIZE); @NotNull Wire wire = new BinaryWire(bytes); try (DocumentContext dc = wire.writingDocument(true)) { dc.wire().writeEventName(() -> "header") .typePrefix(SingleChronicleQueueStore.class).marshallable( w -> w.write(() -> "wireType").object(WireType.BINARY));