Java Callback.succeeded方法代码示例

import org.eclipse.jetty.util.Callback; //导入方法依赖的package包/类
@Override
protected void onResponseContent(final HttpServletRequest request, final HttpServletResponse response, final Response proxyResponse,
		final byte[] buffer, final int offset, final int length, final Callback callback) {
	final int plainStatus = needPlainPageErrorStatus(request, proxyResponse.getStatus());
	if (plainStatus == 0) {
		super.onResponseContent(request, response, proxyResponse, buffer, offset, length, callback);
	} else {
		try {
			// Standard 404/... page, abort the original response
			final RequestDispatcher dispatcher = getServletContext().getRequestDispatcher("/" + plainStatus + ".html");
			dispatcher.forward(getRoot(request), response);
			callback.succeeded();
		} catch (final Exception e) {
			callback.failed(e);
		}
	}
}
 

import org.eclipse.jetty.util.Callback; //导入方法依赖的package包/类
@Override
public void onData(Stream stream, DataFrame frame, Callback callback) {
  LOG.info(frame);
  callback.succeeded();
  if (frame.isEndStream()) {
    phaser.arrive();
  }
}
 

import org.eclipse.jetty.util.Callback; //导入方法依赖的package包/类
protected void onResponseContent(HttpServletRequest request, HttpServletResponse response, Response proxyResponse, byte[] buffer, int offset, int length, Callback callback) {
		try {
			// if (_log.isDebugEnabled())
			_log.info("{} proxying content to downstream: {} bytes", getRequestId(request), length);
			// System.err.println("buffer:" + new String(buffer));
			// response.setHeader("version", "1.1");
			// org.eclipse.jetty.server.Request req = (org.eclipse.jetty.server.Request) request;

			// req.setHttpVersion(HttpVersion.HTTP_1_1);
			// req.getHttpVersion().

			// HttpVersion dd;
			// org.eclipse.jetty.server.Response res = (org.eclipse.jetty.server.Response) response;
			// // res.
			// org.eclipse.jetty.server.HttpOutput output = (HttpOutput) response.getOutputStream();
			//
			// HttpConnection conn = (HttpConnection) output.getInterceptor();
			// System.out.println("response.getOutputStream():" + response.getOutputStream().getClass().getName());
			System.err.println("response:" + response.getClass().getName());

			// response.getWriter().write(new String(buffer));
			// response.flushBuffer();
//			response.getOutputStream().write(buffer, offset, length);
			OutputStream out = response.getOutputStream();
			out.write(buffer);
			out.flush();
			callback.succeeded();
		}
		catch (Throwable x) {
			callback.failed(x);
		}
	}
 

import org.eclipse.jetty.util.Callback; //导入方法依赖的package包/类
protected void onResponseContent(HttpServletRequest request, HttpServletResponse response, Response proxyResponse, byte[] buffer, int offset, int length, Callback callback) {
    try {
        if (LOG.isDebugEnabled()) LOG.debug("{} proxying content to downstream: {} bytes", getRequestId(request), length);
        response.getOutputStream().write(buffer, offset, length);
        callback.succeeded();
    } catch (Throwable x) {
        LOG.error("Error:", x);
        callback.failed(x);
    }
}
 

import org.eclipse.jetty.util.Callback; //导入方法依赖的package包/类
@Override
public void onData(Stream stream, DataFrame frame, Callback callback) {
    byte[] bytes = new byte[frame.getData().remaining()];
    frame.getData().get(bytes);
    System.out.println("[" + frame.getStreamId() + "] DATA " + new String(bytes));
    callback.succeeded();
    
    if (frame.isEndStream()) {
        completedFuture.complete(null);
    }
}
 

import org.eclipse.jetty.util.Callback; //导入方法依赖的package包/类
@Override
public void send(MetaData.Response info, boolean head,
                 ByteBuffer content, boolean lastContent, Callback callback) {

    if (info != null) {
        this.info = info;
    }

    final int length = content.remaining();
    if (length == 0) {
        callback.succeeded();
        return;
    }

    if (content.hasArray()) {
        final int from = content.arrayOffset() + content.position();
        out.add(HttpData.of(Arrays.copyOfRange(content.array(), from, from + length)));
        content.position(content.position() + length);
    } else {
        final byte[] data = new byte[length];
        content.get(data);
        out.add(HttpData.of(data));
    }

    contentLength += length;
    callback.succeeded();
}
 

import org.eclipse.jetty.util.Callback; //导入方法依赖的package包/类
@Override
public void onContent(Response response, ByteBuffer content, Callback callback) {
    emit(new ReactiveResponse.Event(ReactiveResponse.Event.Type.CONTENT, request.getReactiveResponse(), content));
    callback.succeeded();
}
 

import org.eclipse.jetty.util.Callback; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
    long startTime = System.nanoTime();

    // Create and start HTTP2Client.
    HTTP2Client client = new HTTP2Client();
    SslContextFactory sslContextFactory = new SslContextFactory(true);
    client.addBean(sslContextFactory);
    client.start();

    // Connect to host.
    String host = "localhost";
    int port = 8443;

    FuturePromise<Session> sessionPromise = new FuturePromise<>();
    client.connect(sslContextFactory, new InetSocketAddress(host, port), new ServerSessionListener.Adapter(), sessionPromise);

    // Obtain the client Session object.
    Session session = sessionPromise.get(5, TimeUnit.SECONDS);

    // Prepare the HTTP request headers.
    HttpFields requestFields = new HttpFields();
    requestFields.put("User-Agent", client.getClass().getName() + "/" + Jetty.VERSION);
    // Prepare the HTTP request object.
    MetaData.Request request = new MetaData.Request("GET", new HttpURI("https://" + host + ":" + port + "/"), HttpVersion.HTTP_2, requestFields);
    // Create the HTTP/2 HEADERS frame representing the HTTP request.
    HeadersFrame headersFrame = new HeadersFrame(request, null, true);

    // Prepare the listener to receive the HTTP response frames.
    Stream.Listener responseListener = new Stream.Listener.Adapter()
    {
        @Override
        public void onData(Stream stream, DataFrame frame, Callback callback)
        {
            byte[] bytes = new byte[frame.getData().remaining()];
            frame.getData().get(bytes);
            int duration = (int) TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - startTime);
            System.out.println("After " + duration + " seconds: " + new String(bytes));
            callback.succeeded();
        }
    };

    session.newStream(headersFrame, new FuturePromise<>(), responseListener);
    session.newStream(headersFrame, new FuturePromise<>(), responseListener);
    session.newStream(headersFrame, new FuturePromise<>(), responseListener);

    Thread.sleep(TimeUnit.SECONDS.toMillis(20));

    client.stop();
}
 

import org.eclipse.jetty.util.Callback; //导入方法依赖的package包/类
private void process(ByteBuffer content, Callback callback, boolean finished) throws IOException {
	ContentTransformer transformer = dialog.attribute(CLIENT_TRANSFORMER, strategy::requestTransform);

	boolean committed = dialog.hasAttribute(PROXY_REQUEST_COMMITTED);

	int contentBytes = content.remaining();

	// Skip transformation for empty non-last buffers.
	if (contentBytes == 0 && !finished) {
		callback.succeeded();
		return;
	}

	try {
		transformer.transform(content, finished, buffers);
	} catch (Throwable x) {
		_log.info("Exception while transforming " + transformer, x);
		throw x;
	}

	int newContentBytes = 0;
	int size = buffers.size();
	if (size > 0) {
		CountingCallback counter = new CountingCallback(callback, size);
		for (int i = 0; i < size; ++i) {
			ByteBuffer buffer = buffers.get(i);
			newContentBytes += buffer.remaining();
			provider.offer(buffer, counter);
		}
		buffers.clear();
	}

	if (finished)
		provider.close();

	_log.debug("{} upstream content transformation {} -> {} bytes", dialog.id(), contentBytes, newContentBytes);

	if (!committed && (size > 0 || finished)) {
		dialog.requestHeader(HttpHeader.CONTENT_LENGTH, null);
		dialog.attribute(PROXY_REQUEST_COMMITTED, () -> true);
		dialog.send(new ProxyResponseListener(dialog, strategy));
	}

	if (size == 0)
		callback.succeeded();
}