@Test public void testSuspendParsing() { FakeStream<Buffer> stream = new FakeStream<>(); RecordParser parser = RecordParser.newDelimited("\r\n", stream); List<Buffer> emitted = new ArrayList<>(); parser.handler(emitted::add); parser.pause().fetch(1); stream.emit(Buffer.buffer("abc\r\ndef\r\n")); parser.fetch(1); assertEquals(Arrays.asList(Buffer.buffer("abc"), Buffer.buffer("def")), emitted); }
@Override public BatchStream handler(Handler<Batch> handler) { if (handler == null) { recordParser.handler(null); recordParser.exceptionHandler(null); recordParser.endHandler(null); return this; recordParser.handler(buffer -> { try { recordParser.fixedSizeMode(size); recordParser.fixedSizeMode(4);
private void feedChunks(Buffer input, RecordParser parser, Integer[] chunkSizes) { int pos = 0; int chunkPos = 0; while (pos < input.length()) { int chunkSize = chunkSizes[chunkPos++]; if (chunkPos == chunkSizes.length) chunkPos = 0; int end = pos + chunkSize; end = end <= input.length() ? end : input.length(); Buffer sub = input.getBuffer(pos, end); parser.handle(sub); pos += chunkSize; } }
public BatchStream(ReadStream<Buffer> rs, WriteStream<Buffer> ws) { Objects.requireNonNull(rs, "ReadStream"); Objects.requireNonNull(ws, "WriteStream"); recordParser = RecordParser.newFixed(4, rs); writeStream = ws; // Propagate exceptions to the current stream recordParser.exceptionHandler(throwable -> { if (exceptionHandler != null) { exceptionHandler.handle(throwable); } }); writeStream.exceptionHandler(throwable -> { if (exceptionHandler != null) { exceptionHandler.handle(throwable); } }); }
private Handler<NetSocket> getServerHandler() { return socket -> { RecordParser parser = RecordParser.newFixed(4); Handler<Buffer> handler = new Handler<Buffer>() { int size = -1; public void handle(Buffer buff) { if (size == -1) { size = buff.getInt(0); parser.fixedSizeMode(size); } else { ClusteredMessage received = new ClusteredMessage(); received.readFromWire(buff, codecManager); if (metrics != null) { metrics.messageRead(received.address(), buff.length()); } parser.fixedSizeMode(4); size = -1; if (received.codec() == CodecManager.PING_MESSAGE_CODEC) { // Just send back pong directly on connection socket.write(PONG); } else { deliverMessageLocally(received); } } } }; parser.setOutput(handler); socket.handler(parser); }; }
@Test public void testWrapReadStream() { FakeStream<Buffer> stream = new FakeStream<>(); RecordParser parser = RecordParser.newDelimited("\r\n", stream); AtomicInteger ends = new AtomicInteger(); parser.endHandler(v -> ends.incrementAndGet()); Deque<String> records = new ArrayDeque<>(); parser.handler(record -> records.add(record.toString())); assertFalse(stream.isPaused()); parser.pause(); parser.resume(); stream.emit(Buffer.buffer("first\r\nsecond\r\nthird")); assertEquals("first", records.poll()); stream.fail(cause); List<Throwable> failures = new ArrayList<>(); parser.exceptionHandler(failures::add); stream.fail(cause); assertEquals(Collections.singletonList(cause), failures); parser.pause(); assertFalse(stream.isPaused()); int count = 0; } while (!stream.isPaused()); assertNull(records.poll()); parser.resume(); for (int i = 0;i < count;i++) { assertEquals("item-" + i, records.poll());
@Override public void start() throws Exception { vertx.createNetServer().connectHandler(sock -> { RecordParser parser = RecordParser.newDelimited("\n", sock); parser .endHandler(v -> sock.close()) .exceptionHandler(t -> { t.printStackTrace(); sock.close(); }) .handler(buffer -> { String name = buffer.toString("UTF-8"); sock.write("Hello " + name + "\n", "UTF-8"); }); }).listen(1234); System.out.println("Echo server is now listening"); } }
private void doTestDelimited(final Buffer input, Buffer delim, Integer[] chunkSizes, final Buffer... expected) { final Buffer[] results = new Buffer[expected.length]; Handler<Buffer> out = new Handler<Buffer>() { int pos; public void handle(Buffer buff) { results[pos++] = buff; } }; RecordParser parser = RecordParser.newDelimited(delim, out); feedChunks(input, parser, chunkSizes); checkResults(expected, results); }
private static void readValue(String key, RecordParser parser) { parser.fixedSizeMode(4); parser.handler(valueLength -> finishEntry(key, valueLength, parser)); parser.fetch(1); }
@Test public void testIllegalArguments() { assertNullPointerException(() -> RecordParser.newDelimited((Buffer) null, handler -> {})); assertNullPointerException(() -> RecordParser.newDelimited((String) null, handler -> {})); RecordParser parser = RecordParser.newDelimited("", handler -> {}); assertNullPointerException(() -> parser.setOutput(null)); assertNullPointerException(() -> parser.delimitedMode((Buffer) null)); assertNullPointerException(() -> parser.delimitedMode((String) null)); assertIllegalArgumentException(() -> parser.maxRecordSize(-1)); }
private static void finishEntry(String key, Buffer valueLength, RecordParser parser) { parser.fixedSizeMode(valueLength.getInt(0)); parser.handler(value -> { logger.info("Key: {} / Value: {}", key, value); parser.fixedSizeMode(4); parser.handler(keyLength -> readKey(keyLength, parser)); }); } }
public static void main(String[] args) { Vertx vertx = Vertx.vertx(); AsyncFile file = vertx.fileSystem().openBlocking("sample.db", new OpenOptions().setRead(true)); RecordParser parser = RecordParser.newFixed(4, file); parser.pause(); parser.fetch(1); parser.handler(header -> readMagicNumber(header, parser)); parser.endHandler(v -> vertx.close()); }
private void doTestDelimitedMaxRecordSize(final Buffer input, Buffer delim, Integer[] chunkSizes, int maxRecordSize, Handler<Throwable> exHandler, final Buffer... expected) { final Buffer[] results = new Buffer[expected.length]; Handler<Buffer> out = new Handler<Buffer>() { int pos; public void handle(Buffer buff) { results[pos++] = buff; } }; RecordParser parser = RecordParser.newDelimited(delim, out); parser.maxRecordSize(maxRecordSize); parser.exceptionHandler(exHandler); feedChunks(input, parser, chunkSizes); checkResults(expected, results); } }
private void onReadOnePackage(Buffer headerBuffer, Buffer bodyBuffer) { outputHandler.handle(msgId, headerBuffer, bodyBuffer); parser.fixedSizeMode(TCP_HEADER_LENGTH); status = ParseStatus.TCP_HEADER; }
private void handleClient(NetSocket socket) { logger.info("New connection"); RecordParser.newDelimited("\n", socket) .handler(buffer -> handleBuffer(socket, buffer)) .endHandler(v -> logger.info("Connection ended")); }
/** * Create a new <code>RecordParser</code> instance, initially in fixed size mode, and where the record size is specified * by the <code>size</code> parameter. * <p> * <code>output</code> Will receive whole records which have been parsed. * @param size the initial record size * @return */ public static io.vertx.rxjava.core.parsetools.RecordParser newFixed(int size) { io.vertx.rxjava.core.parsetools.RecordParser ret = io.vertx.rxjava.core.parsetools.RecordParser.newInstance(io.vertx.core.parsetools.RecordParser.newFixed(size)); return ret; }
public static void main(String[] args) { Vertx vertx = Vertx.vertx(); AsyncFile file = vertx.fileSystem().openBlocking("sample.db", new OpenOptions().setRead(true)); RecordParser parser = RecordParser.newFixed(4, file); parser.handler(header -> readMagicNumber(header, parser)); parser.endHandler(v -> vertx.close()); }
@Override public void start() { if (ACTIVE.compareAndSet(false, true)) { stdin = RecordParser.newDelimited(System.getProperty("line.separator"), line -> { stdin.handle(Buffer.buffer(script + System.getProperty("line.separator"))); } else { data = tmp; stdin.handle(Buffer.buffer(data));
private static void readVersion(Buffer header, RecordParser parser) { logger.info("Version: {}", header.getInt(0)); parser.delimitedMode("\n"); parser.handler(name -> readName(name, parser)); parser.fetch(1); }