protected HttpGenerator newHttpGenerator(Buffers responseBuffers, EndPoint endPoint) { return new HttpGenerator(responseBuffers, endPoint); }
@Override protected void reset() { generator.reset(); super.reset(); }
/** * Complete the message. * * @throws IOException */ @Override public void complete() throws IOException { if (_state == STATE_END) return; super.complete(); if (_state < STATE_FLUSHING) { _state = STATE_FLUSHING; if (_contentLength == HttpTokens.CHUNKED_CONTENT) _needEOC = true; } flushBuffer(); }
generateResponseLine(info,header); generateHeaders(info,header,content,last); if (isChunking() && !head) prepareChunk(header,len); if (isChunking()) prepareChunk(chunk,len); BufferUtil.flipToFlush(chunk,0); reset(); return Result.DONE; if (isChunking()) prepareChunk(chunk,0); BufferUtil.flipToFlush(chunk,0); _endOfContent=EndOfContent.UNKNOWN_CONTENT;
Buffer sb=new ByteArrayBuffer(4*1024); StringEndPoint endp = new StringEndPoint(_charset); HttpGenerator generator = new HttpGenerator(new SimpleBuffers(sb,bb),endp); generator.setRequest(getMethod(),getURI()); if (_version==null) generator.setVersion(HttpVersions.HTTP_1_1_ORDINAL); else generator.setVersion(HttpVersions.CACHE.getOrdinal(HttpVersions.CACHE.lookup(_version))); generator.completeHeader(_fields,false); if (_genContent!=null) generator.addContent(new View(new ByteArrayBuffer(_genContent)),false); else if (_parsedContent!=null) generator.addContent(new ByteArrayBuffer(_parsedContent.toByteArray()),false); generator.complete(); generator.flushBuffer(); return endp.getOutput();
if (!_generator.isCommitted() && exchange!=null && exchange.getStatus() == HttpExchange.STATUS_WAITING_FOR_COMMIT) while (_generator.isCommitted() && !_generator.isComplete()) if (_generator.flushBuffer()>0) if (_generator.isState(AbstractGenerator.STATE_CONTENT)) _generator.complete(); else if (_generator.isEmpty()) _generator.addContent(chunk,_requestContentChunk==null); if (_requestContentChunk==null) exchange.setStatus(HttpExchange.STATUS_WAITING_FOR_RESPONSE); if (_generator.isComplete() && !_requestComplete) LOG.debug("{}",_endp); boolean complete = failed || _generator.isComplete() && _parser.isComplete(); boolean persistent = !failed && _parser.isPersistent() && _generator.isPersistent(); _generator.setPersistent(persistent); reset(); if (persistent) _generator.returnBuffers();
generateResponseLine(info,header); generateHeaders(info,header,content,last); if (isChunking() && !head) prepareChunk(header,len); return committed(chunk,content,last); reset(); return Result.DONE; return completing(chunk,content);
generateRequestLine(info,header); generateHeaders(info,header,content,last); if (isChunking()) prepareChunk(header,len); if (isChunking()) return Result.NEED_CHUNK; BufferUtil.clearToFill(chunk); prepareChunk(chunk,len); BufferUtil.flipToFlush(chunk,0); if (isChunking()) return Result.NEED_CHUNK; BufferUtil.clearToFill(chunk); prepareChunk(chunk,0); BufferUtil.flipToFlush(chunk,0); _endOfContent=EndOfContent.UNKNOWN_CONTENT;
HttpGenerator generator = new HttpGenerator(); HttpGenerator.Info info = getInfo(); loop: while(!generator.isEnd()) ?generator.generateRequest((RequestInfo)info,header,chunk,content,true) :generator.generateResponse((ResponseInfo)info,header,chunk,content,true); switch(result)
generateRequestLine(info,header); generateHeaders(info,header,content,last); if (isChunking()) prepareChunk(header,len); return committed(chunk,content,last); return completing(chunk,content);
if (isResponse() && _status==0) throw new EofException(); if (isRequest()) if (isRequest()) field.putTo(_header); if (isResponse()) _persistent=false; keep_alive=false; if (!_persistent && isResponse() && _contentLength == HttpTokens.UNKNOWN_CONTENT) _contentLength = HttpTokens.EOF_CONTENT; break; if (isResponse()) _persistent = true; if (isResponse()) if (isResponse()) _persistent=false; if (!_persistent && isResponse() && _contentLength == HttpTokens.UNKNOWN_CONTENT) _contentLength = HttpTokens.EOF_CONTENT; break; if (isResponse()) _persistent=true;
public void reset() { // If we are still expecting if (_channel.isExpecting100Continue()) { // reset to avoid seeking remaining content _parser.reset(); // close to seek EOF _parser.close(); } // else if we are persistent else if (_generator.isPersistent()) // reset to seek next request _parser.reset(); else // else seek EOF _parser.close(); _generator.reset(); _channel.reset(); releaseRequestBuffer(); if (_chunk!=null) { _bufferPool.release(_chunk); _chunk=null; } }
@Override public void badMessage(int status, String reason) { _generator.setPersistent(false); super.badMessage(status,reason); }
if (getSendServerVersion()) _endOfContent = (!isPersistent() || _info.getHttpVersion().ordinal() < HttpVersion.HTTP_1_1.ordinal() ) ? EndOfContent.EOF_CONTENT : EndOfContent.CHUNKED_CONTENT; if (_response!=null && _endOfContent==EndOfContent.EOF_CONTENT) if (isChunking()) if (!isPersistent() && (close || _info.getHttpVersion().ordinal() > HttpVersion.HTTP_1_0.ordinal())) if (!has_server && status>199 && getSendServerVersion()) header.put(SERVER);
putTo(field,header); else putTo(field,header); break; putTo(field,header); putTo(field,header); break; putTo(field,header); putContentLength(header,actual_length,content_type,request,response); if (!isPersistent() || _info.getVersion().ordinal() < HttpVersion.HTTP_1_1.ordinal()) _endOfContent = EndOfContent.EOF_CONTENT; putContentLength(header,content_length,content_type,request,response); break; if (isChunking()) putTo(transfer_encoding,header); else throw new BadMessageException(500,"BAD TE"); if (!isPersistent() && (close || _info.getVersion().ordinal() > HttpVersion.HTTP_1_0.ordinal()))
_generator.setPersistent(false); out: while (true) HttpGenerator.Result result = _generator.generateResponse(info, header, chunk, content, lastContent); if (LOG.isDebugEnabled()) LOG.debug("{} generate: {} ({},{},{})@{}", BufferUtil.toSummaryString(content), lastContent, _generator.getState());
flushBuffer(); if (_content != null && _content.length()>0) _content=null; else if (_endp != null && (_buffer==null || _buffer.length()==0) && _content.length() > 0 && (_last || isCommitted() && _content.length()>1024))
while (true) HttpGenerator.Result result = _generator.generateResponse(_info, _head, _header, chunk, _content, _lastContent); if (LOG.isDebugEnabled()) LOG.debug("{} generate: {} ({},{},{})@{}", BufferUtil.toSummaryString(_content), _lastContent, _generator.getState()); if (_head || _generator.isNoContent())
putTo(field,header); break; putTo(field,header); putTo(field,header); break; putTo(field,header); if (!isPersistent() || _info.getHttpVersion().ordinal() < HttpVersion.HTTP_1_1.ordinal()) _endOfContent = EndOfContent.EOF_CONTENT; if (isChunking()) putTo(transfer_encoding,header); else throw new IllegalArgumentException("BAD TE"); if (!isPersistent() && (close || _info.getHttpVersion().ordinal() > HttpVersion.HTTP_1_0.ordinal()))
public HttpConnection(HttpConfiguration config, Connector connector, EndPoint endPoint) { // Tell AbstractConnector executeOnFillable==true because we want the same thread that // does the HTTP parsing to handle the request so its cache is hot super(endPoint, connector.getExecutor(),true); _config = config; _connector = connector; _bufferPool = _connector.getByteBufferPool(); _generator = new HttpGenerator(); _generator.setSendServerVersion(_config.getSendServerVersion()); _channel = new HttpChannelOverHttp(connector, config, endPoint, this, new Input()); _parser = newHttpParser(); LOG.debug("New HTTP Connection {}", this); }