@Override public void syn(SynInfo synInfo, StreamFrameListener listener, Promise<Stream> promise) { // Synchronization is necessary. // SPEC v3, 2.3.1 requires that the stream creation be monotonically crescent // so we cannot allow thread1 to create stream1 and thread2 create stream3 and // have stream3 hit the network before stream1, not only to comply with the spec // but also because the compression context for the headers would be wrong, as the // frame with a compression history will come before the first compressed frame. int associatedStreamId = 0; if (synInfo instanceof PushSynInfo) associatedStreamId = ((PushSynInfo)synInfo).getAssociatedStreamId(); synchronized (this) { int streamId = streamIds.getAndAdd(2); // TODO: for SPDYv3 we need to support the "slot" argument SynStreamFrame synStream = new SynStreamFrame(version, synInfo.getFlags(), streamId, associatedStreamId, synInfo.getPriority(), (short)0, synInfo.getHeaders()); IStream stream = createStream(synStream, listener, true, promise); if (stream == null) return; generateAndEnqueueControlFrame(stream, synStream, synInfo.getTimeout(), synInfo.getUnit(), stream); } }
Headers headers = new Headers(clientSynInfo.getHeaders(), false);
public StreamFrameListener proxy(final Stream clientStream, SynInfo clientSynInfo, ProxyEngineSelector.ProxyServerInfo proxyServerInfo) String method = clientSynInfo.getHeaders().get(HTTPSPDYHeader.METHOD.name(version)).getValue(); String path = clientSynInfo.getHeaders().get(HTTPSPDYHeader.URI.name(version)).getValue(); Fields headers = new Fields(clientSynInfo.getHeaders(), false);
LOG.debug("Received {} on {}", synInfo, stream); Fields headers = synInfo.getHeaders();
Fields headers = new Fields(clientSynInfo.getHeaders(), false);
@Override public StreamFrameListener onSyn(final Stream stream, SynInfo synInfo) { // Every time we have a SYN, it maps to a HTTP request. // We can have multiple concurrent SYNs on the same connection, // and this is very different from HTTP, where only one request/response // cycle is processed at a time, so we need to fake an http connection // for each SYN in order to run concurrently. logger.debug("Received {} on {}", synInfo, stream); HTTPSPDYAsyncEndPoint asyncEndPoint = new HTTPSPDYAsyncEndPoint(endPoint, stream); ServerHTTPSPDYAsyncConnection connection = new ServerHTTPSPDYAsyncConnection(connector, asyncEndPoint, connector.getServer(), getVersion(), (SPDYAsyncConnection)endPoint.getConnection(), pushStrategy, stream); asyncEndPoint.setConnection(connection); stream.setAttribute(CONNECTION_ATTRIBUTE, connection); Headers headers = synInfo.getHeaders(); connection.beginRequest(headers, synInfo.isClose()); if (headers.isEmpty()) { // If the SYN has no headers, they may come later in a HEADERS frame return this; } else { if (synInfo.isClose()) return null; else return this; } }
@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; }
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; }
public StreamFrameListener proxy(final Stream clientStream, SynInfo clientSynInfo, ProxyEngineSelector.ProxyServerInfo proxyServerInfo) { Headers headers = new Headers(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); StreamHandler handler = new StreamHandler(clientStream, serverSynInfo); clientStream.setAttribute(STREAM_HANDLER_ATTRIBUTE, handler); serverSession.syn(serverSynInfo, listener, timeout, TimeUnit.MILLISECONDS, handler); return this; }