Java ReadStream类代码示例

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
@Override
public FdfsClient modify(ReadStream<Buffer> stream, long size, FdfsFileId fileId, long offset,
		Handler<AsyncResult<Void>> handler) {
	getTracker().setHandler(tracker -> {
		if (tracker.succeeded()) {
			tracker.result().getStoreStorage(fileId.group(), storage -> {
				if (storage.succeeded()) {
					storage.result().modify(stream, size, fileId, offset, modify -> {
						handler.handle(modify);
					});
				} else {
					handler.handle(Future.failedFuture(storage.cause()));
				}
			});
		} else {
			handler.handle(Future.failedFuture(tracker.cause()));
		}
	});

	return this;
}
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
@Override
public FdfsClient append(ReadStream<Buffer> stream, long size, FdfsFileId fileId,
		Handler<AsyncResult<Void>> handler) {
	getTracker().setHandler(tracker -> {
		if (tracker.succeeded()) {
			tracker.result().getStoreStorage(fileId.group(), storage -> {
				if (storage.succeeded()) {
					storage.result().append(stream, size, fileId, append -> {
						handler.handle(append);
					});
				} else {
					handler.handle(Future.failedFuture(storage.cause()));
				}
			});
		} else {
			handler.handle(Future.failedFuture(tracker.cause()));
		}
	});

	return this;
}
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
/**
 * Simple test to fake a _tenantPermission interface.
 * Captures the body, and reports it in a header.
 *
 * @param ctx
 */
private void myPermissionHandle(RoutingContext ctx) {
  ReadStream<Buffer> content = ctx.request();
  final Buffer incoming = Buffer.buffer();
  content.handler(incoming::appendBuffer);
  ctx.request().endHandler(x -> {
    String body = incoming.toString();
    body = body.replaceAll("\\s+", " "); // remove newlines etc
    ctx.response().putHeader("X-Tenant-Perms-Result", body);
    if (body.length() > 80) {
      body = body.substring(0, 80) + "...";
    }
    logger.info("tenantPermissions: " + body);
    ctx.response().end();
  });
}
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
@Test
public void testClosedKeyStream() {
  Map<JsonObject, Buffer> map = genJsonToBuffer(100);
  loadData(map, (vertx, asyncMap) -> {
    List<JsonObject> keys = new ArrayList<>();
    ReadStream<JsonObject> stream = InfinispanAsyncMap.<JsonObject, Buffer>unwrap(asyncMap).keyStream();
    stream.exceptionHandler(t -> {
      fail(t);
    }).handler(jsonObject -> {
      keys.add(jsonObject);
      if (jsonObject.getInteger("key") == 38) {
        stream.handler(null);
        int emitted = keys.size();
        vertx.setTimer(500, tid -> {
          assertTrue("Items emitted after close", emitted == keys.size());
          testComplete();
        });
      }
    });
  });
  await();
}
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
private void proxyRequestResponse10(Iterator<ModuleInstance> it,
  ProxyContext pc, ReadStream<Buffer> stream, Buffer bcontent,
  ModuleInstance mi) {

  if (bcontent != null) {
    proxyRequestResponse(it, pc, null, bcontent, mi);
  } else {
    final Buffer incoming = Buffer.buffer();
    stream.handler(data -> {
      incoming.appendBuffer(data);
      pc.trace("ProxyRequestBlock request chunk '"
        + data.toString() + "'");
    });
    stream.endHandler(v -> {
      pc.trace("ProxyRequestBlock request end");
      proxyRequestResponse(it, pc, null, incoming, mi);
    });
    stream.resume();
  }
}
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
private void proxyInternal(Iterator<ModuleInstance> it,
  ProxyContext pc, ReadStream<Buffer> stream, Buffer bcontent,
  ModuleInstance mi) {

  pc.debug("proxyInternal " + mi.getModuleDescriptor().getId());
  if (bcontent != null) {
    proxyInternalBuffer(it, pc, bcontent, mi);
  } else { // read the whole request into a buffer
    final Buffer incoming = Buffer.buffer();
    stream.handler(data -> {
      incoming.appendBuffer(data);
      pc.trace("proxyInternal request chunk '"
        + data.toString() + "'");
    });
    stream.endHandler(v -> {
      pc.trace("proxyInternal request end");
      proxyInternalBuffer(it, pc, incoming, mi);
    });
    stream.resume();
  }
}
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
public void testSmall(TestContext context, boolean encrypt) throws IOException {

        SfsVertx sfsVertx = new SfsVertxImpl(rule.vertx(), backgroundPool, ioPool);
        Path tmpDir = createTempDirectory(valueOf(currentTimeMillis()));

        Buffer testBuffer = buffer("test");
        Async async = context.async();
        aVoid()
                .flatMap(aVoid -> {
                    FileBackedBuffer fileBackedBuffer = new FileBackedBuffer(sfsVertx, 2, encrypt, tmpDir);
                    ReadStream<Buffer> readStream = new BufferReadStream(testBuffer);
                    return pump(readStream, fileBackedBuffer)
                            .flatMap(aVoid1 -> {
                                ReadStream<Buffer> fileBackedReadStream = fileBackedBuffer.readStream();
                                BufferWriteEndableWriteStream bufferedWriteStreamConsumer = new BufferWriteEndableWriteStream();
                                return pump(fileBackedReadStream, bufferedWriteStreamConsumer)
                                        .doOnNext(aVoid2 -> {
                                            Buffer actualBuffer = bufferedWriteStreamConsumer.toBuffer();
                                            assertArrayEquals(context, testBuffer.getBytes(), actualBuffer.getBytes());
                                            assertEquals(context, true, fileBackedBuffer.isFileOpen());
                                        });
                            })
                            .flatMap(aVoid1 -> fileBackedBuffer.close());
                })
                .subscribe(new TestSubscriber(context, async));
    }
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
public void testOnlyBuffer(TestContext context, boolean encrypt) throws IOException {

        SfsVertx sfsVertx = new SfsVertxImpl(rule.vertx(), backgroundPool, ioPool);
        Path tmpDir = createTempDirectory(valueOf(currentTimeMillis()));

        Buffer testBuffer = buffer("test");
        Async async = context.async();
        aVoid()
                .flatMap(aVoid -> {
                    FileBackedBuffer fileBackedBuffer = new FileBackedBuffer(sfsVertx, 1024, encrypt, tmpDir);
                    ReadStream<Buffer> readStream = new BufferReadStream(testBuffer);
                    return pump(readStream, fileBackedBuffer)
                            .flatMap(aVoid1 -> {
                                ReadStream<Buffer> fileBackedReadStream = fileBackedBuffer.readStream();
                                BufferWriteEndableWriteStream bufferedWriteStreamConsumer = new BufferWriteEndableWriteStream();
                                return pump(fileBackedReadStream, bufferedWriteStreamConsumer)
                                        .doOnNext(aVoid2 -> {
                                            Buffer actualBuffer = bufferedWriteStreamConsumer.toBuffer();
                                            assertArrayEquals(context, testBuffer.getBytes(), actualBuffer.getBytes());
                                            assertEquals(context, false, fileBackedBuffer.isFileOpen());
                                        });
                            })
                            .flatMap(aVoid1 -> fileBackedBuffer.close());
                })
                .subscribe(new TestSubscriber(context, async));
    }
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
/**
 * <p>Search the GeoRocket data store and return a {@link ReadStream} of
 * merged chunks matching the given criteria.</p>
 * <p>If <code>query</code> is <code>null</code> or empty all chunks from
 * the given <code>layer</code> (and all sub-layers) will be returned. If
 * <code>layer</code> is also <code>null</code> or empty the contents of the
 * whole data store will be returned.</p>
 * <p>The caller is responsible for handling exceptions through
 * {@link ReadStream#exceptionHandler(Handler)}.</p>
 * @param query a search query specifying which chunks to return (may be
 * <code>null</code>)
 * @param layer the name of the layer where to search for chunks recursively
 * (may be <code>null</code>)
 * @param handler a handler that will receive the {@link ReadStream} from
 * which the merged chunks matching the given criteria can be read
 */
public void search(String query, String layer,
    Handler<AsyncResult<ReadStream<Buffer>>> handler) {
  if ((query == null || query.isEmpty()) && (layer == null || layer.isEmpty())) {
    handler.handle(Future.failedFuture("No search query and no layer given. "
        + "Do you really wish to export/query the whole data store? If so, "
        + "set the layer to '/'."));
    return;
  }
  String queryPath = prepareQuery(query, layer);
  HttpClientRequest request = client.get(getEndpoint() + queryPath);
  request.exceptionHandler(t -> handler.handle(Future.failedFuture(t)));
  request.handler(response -> {
    if (response.statusCode() == 404) {
      fail(response, handler, message -> new NoSuchElementException(ClientAPIException.parse(message).getMessage()));
    } else if (response.statusCode() != 200) {
      fail(response, handler);
    } else {
      handler.handle(Future.succeededFuture(response));
    }
  });
  configureRequest(request).end();
}
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
public MultipartHelper putBinaryBody(String name, ReadStream<Buffer> stream, String contentType, String fileName, Handler<AsyncResult> handler) {
    request
            .write("--")
            .write(boundary)
            .write(System.lineSeparator())
            .write(String.format("Content-Disposition: form-data; name=\"%s\"; filename=\"%s\"", name, fileName))
            .write(System.lineSeparator())
            .write(String.format("Content-Type: %s", contentType))
            .write(System.lineSeparator())
            .write("Content-Transfer-Encoding: binary")
            .write(System.lineSeparator())
            .write(System.lineSeparator());
    Pump.pump(stream
            .endHandler(event -> {
                request.write(System.lineSeparator());
                handler.handle(createResult(true, null));
            })
            .exceptionHandler(e -> handler.handle(createResult(false, e))), request)
            .start();
    return this;
}
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
@Override
public ReadStream<JsonObject> resume() {
  JsonObject conf;
  Handler<JsonObject> succ;
  synchronized (this) {
    if (! paused) {
      // Cannot resume a non paused stream
      return this;
    }

    paused = false;
    conf = last;
    if (last != null) {
      last = null;
    }
    succ = this.handler;
  }

  if (conf != null && succ != null) {
    vertx.runOnContext(v -> succ.handle(conf));
  }

  return this;
}
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
/**
 * Asynchronously store content from source to filePath,
 * and call onEnd when finished
 * @param source
 * @param filePath
 * @param onEnd
 */
public static void asyncStore(Vertx vertx,
                       ReadStream<Buffer> source,
                       String filePath,
                       Handler<Void> onEnd) {
    checkDir(filePath);
    source.pause();
    vertx.fileSystem().open(filePath,
            new OpenOptions().setWrite(true).setCreate(true),
            fres -> {
                AsyncFile afile = fres.result();
                Pump pump = Pump.pump(source, afile);
                source.endHandler(onEnd);
                pump.start();
                source.resume();
            });
}
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
@Override
public FdfsClient upload(ReadStream<Buffer> stream, long size, String ext,
		Handler<AsyncResult<FdfsFileId>> handler) {

	if (Buffer.buffer(ext, options.getCharset()).length() > FdfsProtocol.FDFS_FILE_EXT_NAME_MAX_LEN) {
		handler.handle(Future
				.failedFuture("ext is too long ( greater than " + FdfsProtocol.FDFS_FILE_EXT_NAME_MAX_LEN + ")"));
		return this;
	}

	getTracker().setHandler(tracker -> {
		if (tracker.succeeded()) {
			tracker.result().getStoreStorage(storage -> {
				if (storage.succeeded()) {
					storage.result().upload(stream, size, ext, upload -> {
						handler.handle(upload);
					});
				} else {
					handler.handle(Future.failedFuture(storage.cause()));
				}
			});
		} else {
			handler.handle(Future.failedFuture(tracker.cause()));
		}
	});

	return this;
}
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
@Override
public FdfsClient uploadAppender(ReadStream<Buffer> stream, long size, String ext,
		Handler<AsyncResult<FdfsFileId>> handler) {

	if (Buffer.buffer(ext, options.getCharset()).length() > FdfsProtocol.FDFS_FILE_EXT_NAME_MAX_LEN) {
		handler.handle(Future
				.failedFuture("ext is too long ( greater than " + FdfsProtocol.FDFS_FILE_EXT_NAME_MAX_LEN + ")"));
		return this;
	}

	getTracker().setHandler(tracker -> {
		if (tracker.succeeded()) {
			tracker.result().getStoreStorage(storage -> {
				if (storage.succeeded()) {
					storage.result().uploadAppender(stream, size, ext, uploadAppender -> {
						handler.handle(uploadAppender);
					});
				} else {
					handler.handle(Future.failedFuture(storage.cause()));
				}
			});
		} else {
			handler.handle(Future.failedFuture(tracker.cause()));
		}
	});

	return this;
}
 

import io.vertx.core.streams.ReadStream; //导入依赖的package包/类
private void proxyRedirect(Iterator<ModuleInstance> it,
  ProxyContext pc, ReadStream<Buffer> stream, Buffer bcontent,
  ModuleInstance mi) {

  pc.trace("ProxyNull " + mi.getModuleDescriptor().getId());
  pc.closeTimer();
  // if no more entries in it, proxyR will return 404
  proxyR(it, pc, stream, bcontent);
}