private void data(final Stream stream, final DataInfo dataInfo) { clientStream.data(dataInfo, getTimeout(), TimeUnit.MILLISECONDS, new Handler<Void>() { @Override public void completed(Void context) { dataInfo.consume(dataInfo.length()); logger.debug("P -> C {} from {} to {}", dataInfo, stream, clientStream); } @Override public void failed(Void context, Throwable x) { logger.debug(x); rst(clientStream); } }); } }
@Override public StreamFrameListener onSyn(Stream serverStream, SynInfo serverSynInfo) { logger.debug("S -> P pushed {} on {}", serverSynInfo, serverStream); Headers headers = new Headers(serverSynInfo.getHeaders(), false); addResponseProxyHeaders(serverStream, headers); customizeResponseHeaders(serverStream, headers); Stream clientStream = (Stream)serverStream.getAssociatedStream().getAttribute(CLIENT_STREAM_ATTRIBUTE); convert(serverStream.getSession().getVersion(), clientStream.getSession().getVersion(), headers); StreamHandler handler = new StreamHandler(clientStream, serverSynInfo); serverStream.setAttribute(STREAM_HANDLER_ATTRIBUTE, handler); clientStream.syn(new SynInfo(headers, serverSynInfo.isClose()), getTimeout(), TimeUnit.MILLISECONDS, handler); return this; }
private void respond(Stream stream, int status) { if (stream.isUnidirectional()) { stream.getSession().rst(new RstInfo(stream.getId(), StreamStatus.INTERNAL_ERROR)); } else { Headers headers = new Headers(); headers.put(HTTPSPDYHeader.STATUS.name(version), String.valueOf(status)); headers.put(HTTPSPDYHeader.VERSION.name(version), "HTTP/1.1"); stream.reply(new ReplyInfo(headers, true)); } }
private void rst(Stream stream) { RstInfo rstInfo = new RstInfo(stream.getId(), StreamStatus.REFUSED_STREAM); stream.getSession().rst(rstInfo, Callback.Adapter.INSTANCE); }
@Override public void onRst(Session serverSession, RstInfo serverRstInfo) { Stream serverStream = serverSession.getStream(serverRstInfo.getStreamId()); if (serverStream != null) { Stream clientStream = (Stream)serverStream.getAttribute(CLIENT_STREAM_ATTRIBUTE); if (clientStream != null) { Session clientSession = clientStream.getSession(); RstInfo clientRstInfo = new RstInfo(clientStream.getId(), serverRstInfo.getStreamStatus()); clientSession.rst(clientRstInfo, Callback.Adapter.INSTANCE); } } }
try clientStream.getSession().rst(new RstInfo(clientStream.getId(), StreamStatus.INTERNAL_ERROR)); if (clientStream.isClosed()) return; Fields responseHeaders = createResponseHeaders(clientStream, response); if (failure instanceof TimeoutException) responseHeaders.add(HTTPSPDYHeader.STATUS.name(clientStream.getSession().getVersion()), String.valueOf(HttpStatus.GATEWAY_TIMEOUT_504)); else responseHeaders.add(HTTPSPDYHeader.STATUS.name(clientStream.getSession().getVersion()), String.valueOf(HttpStatus.BAD_GATEWAY_502)); ReplyInfo replyInfo = new ReplyInfo(responseHeaders, true); clientStream.reply(replyInfo, LOGGING_CALLBACK);
private void reply(Stream stream, ReplyInfo replyInfo, Callback callback) { if (!stream.isUnidirectional()) stream.reply(replyInfo, callback); else stream.headers(new HeadersInfo(replyInfo.getHeaders(), replyInfo.isClose()), callback); Fields responseHeaders = replyInfo.getHeaders(); if (responseHeaders.get(HTTPSPDYHeader.STATUS.name(version)).getValue().startsWith("200") && !stream.isClosed()) { Set<String> pushResources = pushStrategy.apply(stream, requestHeaders, responseHeaders); if (pushResources.size() > 0) { PushResourceCoordinator pushResourceCoordinator = new PushResourceCoordinator(pushResources); pushResourceCoordinator.coordinate(); } } }
private void close(Stream stream) { stream.getSession().goAway(); }
protected void reply(Stream stream, ReplyInfo replyInfo) { if (!stream.isUnidirectional()) stream.reply(replyInfo); if (replyInfo.getHeaders().get(HTTPSPDYHeader.STATUS.name(version)).value().startsWith("200") && !stream.isClosed()) { // We have a 200 OK with some content to send Headers.Header scheme = headers.get(HTTPSPDYHeader.SCHEME.name(version)); Headers.Header host = headers.get(HTTPSPDYHeader.HOST.name(version)); Headers.Header uri = headers.get(HTTPSPDYHeader.URI.name(version)); Set<String> pushResources = pushStrategy.apply(stream, headers, replyInfo.getHeaders()); for (String pushResourcePath : pushResources) { final Headers requestHeaders = createRequestHeaders(scheme, host, uri, pushResourcePath); final Headers pushHeaders = createPushHeaders(scheme, host, pushResourcePath); stream.syn(new SynInfo(pushHeaders, false), getMaxIdleTime(), TimeUnit.MILLISECONDS, new Handler.Adapter<Stream>() { @Override public void completed(Stream pushStream) { ServerHTTPSPDYAsyncConnection pushConnection = new ServerHTTPSPDYAsyncConnection(getConnector(), getEndPoint(), getServer(), version, connection, pushStrategy, pushStream); pushConnection.beginRequest(requestHeaders, true); } }); } } }
LOG.debug("Sending {} {} {} {} last={}", this, stream, info, BufferUtil.toDetailString(content), lastContent); if (stream.isClosed() || stream.isReset()) StreamException exception = new StreamException(stream.getId(), StreamStatus.PROTOCOL_ERROR, "Stream already committed!"); callback.failed(exception); LOG.debug("Send content: {} on stream: {} lastContent={}", BufferUtil.toDetailString(content), stream, lastContent); stream.data(new ByteBufferDataInfo(endPoint.getIdleTimeout(), TimeUnit.MILLISECONDS, content, lastContent ), callback); stream.data(new ByteBufferDataInfo(endPoint.getIdleTimeout(), TimeUnit.MILLISECONDS, BufferUtil.EMPTY_BUFFER, lastContent), callback);
@Override public void asyncDispatch() { ServerHTTPSPDYAsyncConnection connection = (ServerHTTPSPDYAsyncConnection)stream.getAttribute(CONNECTION_ATTRIBUTE); connection.async(); }
public StreamFrameListener proxy(final Stream clientStream, SynInfo clientSynInfo, ProxyEngineSelector.ProxyServerInfo proxyServerInfo) { Fields headers = new Fields(clientSynInfo.getHeaders(), false); short serverVersion = getVersion(proxyServerInfo.getProtocol()); InetSocketAddress address = proxyServerInfo.getAddress(); Session serverSession = produceSession(proxyServerInfo.getHost(), serverVersion, address); if (serverSession == null) { rst(clientStream); return null; } final Session clientSession = clientStream.getSession(); addRequestProxyHeaders(clientStream, headers); customizeRequestHeaders(clientStream, headers); convert(clientSession.getVersion(), serverVersion, headers); SynInfo serverSynInfo = new SynInfo(headers, clientSynInfo.isClose()); StreamFrameListener listener = new ProxyStreamFrameListener(clientStream); StreamPromise promise = new StreamPromise(clientStream, serverSynInfo); clientStream.setAttribute(STREAM_PROMISE_ATTRIBUTE, promise); serverSession.syn(serverSynInfo, listener, promise); return this; }
@Override public void flush(long maxIdleTime) throws IOException { try { Buffer content = getContentBuffer(); while (content != null) { DataInfo dataInfo = toDataInfo(content, closed); logger.debug("HTTP < {} bytes of content", dataInfo.length()); stream.data(dataInfo).get(maxIdleTime, TimeUnit.MILLISECONDS); content.clear(); _bypass = false; content = getContentBuffer(); } } catch (TimeoutException x) { stream.getSession().goAway(); throw new EOFException("write timeout"); } catch (InterruptedException x) { throw new InterruptedIOException(); } catch (ExecutionException x) { throw new IOException(x.getCause()); } }
serverStream.setAttribute(CLIENT_STREAM_ATTRIBUTE, clientStream);
private void reply(final Stream stream, final ReplyInfo clientReplyInfo) { receiverStream.reply(clientReplyInfo, new Callback() { @Override public void succeeded() { if (LOG.isDebugEnabled()) LOG.debug("P -> C {} from {} to {}", clientReplyInfo, stream, receiverStream); } @Override public void failed(Throwable x) { LOG.debug(x); rst(receiverStream); } }); }
@Override public long getIdleTimeout() { return stream.getIdleTimeout(); }
@Override public void onRst(Session serverSession, RstInfo serverRstInfo) { Stream serverStream = serverSession.getStream(serverRstInfo.getStreamId()); if (serverStream != null) { Stream clientStream = (Stream)serverStream.getAttribute(CLIENT_STREAM_ATTRIBUTE); if (clientStream != null) { Session clientSession = clientStream.getSession(); RstInfo clientRstInfo = new RstInfo(clientStream.getId(), serverRstInfo.getStreamStatus()); clientSession.rst(clientRstInfo, getTimeout(), TimeUnit.MILLISECONDS, new Handler.Adapter<Void>()); } } }
private void rst(Stream stream) { RstInfo rstInfo = new RstInfo(stream.getId(), StreamStatus.REFUSED_STREAM); stream.getSession().rst(rstInfo); }
public HttpTransportOverSPDY(Connector connector, HttpConfiguration configuration, EndPoint endPoint, PushStrategy pushStrategy, Stream stream, Fields requestHeaders) { this.connector = connector; this.configuration = configuration; this.endPoint = endPoint; this.pushStrategy = pushStrategy == null ? new PushStrategy.None() : pushStrategy; this.stream = stream; this.requestHeaders = requestHeaders; Session session = stream.getSession(); this.version = session.getVersion(); }
@Override public void onData(Stream stream, final DataInfo dataInfo) { if (LOG.isDebugEnabled()) LOG.debug("Received {} on {}", dataInfo, stream); HttpChannelOverSPDY channel = (HttpChannelOverSPDY)stream.getAttribute(CHANNEL_ATTRIBUTE); channel.requestContent(dataInfo, dataInfo.isClose()); }