private long writeHeader(@NotNull Wire wire, int safeLength) { Bytes<?> bytes = wire.bytes(); // writePosition points at the last record in the queue, so we can just skip it and we're ready for write long pos = position; long lastPos = store.writePosition(); if (pos < lastPos) { // queue moved since we last touched it - recalculate header number try { wire.headerNumber(queue.rollCycle().toIndex(cycle, store.lastSequenceNumber(this))); } catch (StreamCorruptedException ex) { Jvm.warn().on(getClass(), "Couldn't find last sequence", ex); } } int header = bytes.readVolatileInt(lastPos); assert header != NOT_INITIALIZED; lastPos += lengthOf(bytes.readVolatileInt(lastPos)) + SPB_HEADER_SIZE; bytes.writePosition(lastPos); return wire.enterHeader(safeLength); }
@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())); } finally { bytes.writePosition(pos); warn().on(getClass(), msgStart + " but message now exists."); return wire.writeHeaderOfUnknownLength(timeoutMS, TimeUnit.MILLISECONDS, lastPosition, sequence);
@Nullable static SingleChronicleQueueStore loadStore(@NotNull Wire wire) { final StringBuilder eventName = new StringBuilder(); wire.readEventName(eventName); if (eventName.toString().equals(MetaDataKeys.header.name())) { final SingleChronicleQueueStore store = wire.read().typedMarshallable(); if (store == null) { throw new IllegalArgumentException("Unable to load wire store"); } return store; } LOGGER.warn("Unable to load store file from input. Queue file may be corrupted."); return null; }
@Override public void writeEOF(@NotNull Wire wire, long timeoutMS) { // just in case we are about to release this if (wire.bytes().tryReserve()) { wire.writeEndOfWire(timeoutMS, TimeUnit.MILLISECONDS, writePosition()); wire.bytes().release(); } else { Jvm.debug().on(getClass(), "Tried to writeEOF to as it was being closed"); } }
private static MessageHistory readHistoryFromBytes(final Wire wire, MessageHistory history) { final Bytes<?> bytes = wire.bytes(); if (MESSAGE_HISTORY_METHOD_ID != wire.readEventNumber()) return null; ((BytesMarshallable) history).readMarshallable(bytes); return history; }
@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; }
@Nullable ScanResult moveToIndex0(@NotNull final ExcerptContext ec, final long index) { return null; @NotNull final LongArrayValues array1 = arrayForAddress(wire, secondaryAddress); long secondaryOffset = toAddress1(index); ec.wire().bytes().readPositionUnlimited(fromAddress); return ScanResult.FOUND; } else {
@Nullable @Override public Excerpt<T, M> getExcerpt(@NotNull T topic) { final ThreadLocalData threadLocalData = threadLocal.get(); @NotNull ExcerptTailer excerptTailer = threadLocalData.replayTailer; for (; ; ) { try (DocumentContext dc = excerptTailer.readingDocument()) { if (!dc.isPresent()) return null; final StringBuilder t = Wires.acquireStringBuilder(); @NotNull final ValueIn valueIn = dc.wire().readEventName(t); @Nullable final T topic1 = convertTo(messageTypeClass, t); if (!topic.equals(topic1)) continue; @Nullable final M message = valueIn.object(elementTypeClass); return threadLocalData.excerpt .message(message) .topic(topic1) .index(excerptTailer.index()); } } }
@Nullable private Marshallable value(@NotNull IndexQuery<V> vanillaIndexQuery, @NotNull ExcerptTailer tailer, @NotNull Iterator<IndexedValue<V>> iterator, final long from) { throw Jvm.rethrow(new InvalidEventHandlerException("shutdown")); Jvm.debug().on(getClass(), "processing the following message=" + fromSizePrefixedBlobs(dc)); @NotNull final ValueIn valueIn = dc.wire().read(eventName); if (dc.isPresent() ) while (dc.wire().hasMore()) { dc.wire().read().skipValue();
@Override public void onConsumer(@NotNull final WireIn inWire) { try (DocumentContext dc = inWire.readingDocument()) { if (!dc.isPresent()) return; final StringBuilder sb = Wires.acquireStringBuilder(); @NotNull final ValueIn valueIn = dc.wire().readEventName(sb); if (reply.contentEquals(sb)) try { @Nullable final IndexedValue<V> e = valueIn.typedMarshallable(); fromIndex = Math.max(fromIndex, e.index()); subscriber.onMessage(e); } catch (InvalidSubscriberException e) { RemoteIndexQueueView.this.unregisterSubscriber(subscriber); } else if (onEndOfSubscription.contentEquals(sb)) { subscriber.onEndOfSubscription(); hub.unsubscribe(tid()); } } catch (Exception e) { Jvm.warn().on(getClass(), e); } } };
private Excerpt<T, M> next(@NotNull ExcerptTailer excerptTailer, @NotNull final LocalExcept excerpt) { excerpt.clear(); try (DocumentContext dc = excerptTailer.readingDocument()) { if (!dc.isPresent()) return null; final Wire wire = dc.wire(); long pos = wire.bytes().readPosition(); final T topic = wire.readEvent(messageTypeClass); @NotNull final ValueIn valueIn = wire.getValueIn(); if (Bytes.class.isAssignableFrom(elementTypeClass)) { valueIn.text(excerpt.text()); } else { @Nullable final M message = valueIn.object(elementTypeClass); excerpt.message(message); } return excerpt .topic(topic) .index(excerptTailer.index()); } }
@Nullable @Override public Void install(@NotNull String path, @NotNull AssetTree assetTree) throws IOException { @NotNull String uri = path + "?putReturnsNull=" + putReturnsNull + "&removeReturnsNull=" + removeReturnsNull; @NotNull MapView mapView = assetTree.acquireMap(uri, keyType, valueType); if (importFile != null) { @NotNull Wire wire = Wire.fromFile(importFile); @NotNull StringBuilder keyStr = new StringBuilder(); while (!wire.isEmpty()) { @Nullable Object value = wire.readEventName(keyStr).object(valueType); @Nullable Object key = ObjectUtils.convertTo(keyType, keyStr); mapView.put(key, value); } } LOGGER.info("Added InMemoryMap " + path + ", size: " + mapView.size()); return null; }
@NotNull private List<Integer> fillResults(@NotNull ExcerptTailer tailer, @NotNull List<Integer> results) { for (int i = 0; i < 10; i++) { try (DocumentContext documentContext = tailer.readingDocument()) { if (!documentContext.isPresent()) break; results.add(documentContext.wire().read(() -> "msg").int32()); } } return results; }
@Override public long recoverAndWriteHeader(@NotNull Wire wire, long timeoutMS, @NotNull final LongValue lastPosition, Sequence sequence) throws UnrecoverableTimeoutException { Jvm.warn().on(getClass(), "Clearing an incomplete header so a header can be written"); wire.bytes().writeInt(0); wire.pauser().reset(); try { return wire.writeHeaderOfUnknownLength(timeoutMS, TimeUnit.MILLISECONDS, lastPosition, sequence); } catch (@NotNull TimeoutException | EOFException e) { throw new UnrecoverableTimeoutException(e); } } }
wire.writeAlignTo(Integer.BYTES, 0); else if (padToCacheAlign) wire.padToCacheAlign(); wire.updateHeader(position, metaData, 0); } catch (IllegalStateException e) { if (queue.isClosed()) lastIndex(wire.headerNumber()); store.writePosition(position); if (lastIndex != Long.MIN_VALUE) } else if (wire != null) { isClosed = true; writeBytesInternal(wire.headerNumber(), wire.bytes()); wire = StoreAppender.this.wire; } catch (@NotNull StreamCorruptedException | UnrecoverableTimeoutException e) { throw new IllegalStateException(e); } finally { writeLock.unlock(); } catch (Exception ex) { Jvm.warn().on(getClass(), "Exception while unlocking: ", ex);
@Override public void dump(@NotNull Writer writer, long fromIndex, long toIndex) { try { long firstIndex = firstIndex(); writer.append("# index: ").append(Long.toHexString(dc.index())).append("\n"); Wire wire = dc.wire(); long start = wire.bytes().readPosition(); try { text.clear(); wire.copyTo(text); writer.append(bytes.toString()); wire.bytes().readPosition(start); writer.append(wire.bytes()).append("\n");
@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; }
void readForward(@NotNull ChronicleQueue chronicle, int entries) { ExcerptTailer forwardTailer = chronicle.createTailer() .direction(TailerDirection.FORWARD) .toStart(); for (int i = 0; i < entries; i++) { try (DocumentContext documentContext = forwardTailer.readingDocument()) { Assert.assertTrue(documentContext.isPresent()); Assert.assertEquals(i, RollCycles.DAILY.toSequenceNumber(documentContext.index())); StringBuilder sb = Wires.acquireStringBuilder(); ValueIn valueIn = documentContext.wire().readEventName(sb); Assert.assertTrue("hello".contentEquals(sb)); String actual = valueIn.text(); Assert.assertEquals("world" + i, actual); } } try (DocumentContext documentContext = forwardTailer.readingDocument()) { Assert.assertFalse(documentContext.isPresent()); } }