Best code snippets using org.eclipse.jetty.util.log.Logger(Showing top 20 results out of 477)

public boolean onRequestComplete()
{
  if (LOG.isDebugEnabled())
    LOG.debug("{} onRequestComplete", this);
  boolean result = _request.getHttpInput().eof();
  notifyRequestEnd(_request);
  return result;
}

public boolean onContent(HttpInput.Content content)
{
  if (LOG.isDebugEnabled())
    LOG.debug("{} onContent {}", this, content);
  notifyRequestContent(_request, content.getByteBuffer());
  return _request.getHttpInput().addContent(content);
}

public void onCompleted()
{
  if (LOG.isDebugEnabled())
    LOG.debug("COMPLETE for {} written={}",getRequest().getRequestURI(),getBytesWritten());
  if (_requestLog!=null )
    _requestLog.log(_request, _response);
  long idleTO=_configuration.getIdleTimeout();
  if (idleTO>=0 && getIdleTimeout()!=_oldIdleTimeout)
    setIdleTimeout(_oldIdleTimeout);
  notifyComplete(_request);
  _transport.onCompleted();
}

private void extractMultipartParameters(MultiMap<String> result)
{
  try
  {
    getParts(result);
  }
  catch (IOException | ServletException e)
  {
    LOG.debug(e);
    throw new RuntimeIOException(e);
  }
}

@Override
public void abort(Throwable failure)
{
  if (LOG.isDebugEnabled())
    LOG.debug("abort {} {}",this,failure);
  // Do a direct close of the output, as this may indicate to a client that the
  // response is bad either with RST or by abnormal completion of chunked response.
  getEndPoint().close();
}

private int fill()
{
  try
  {
    return getEndPoint().fill(BufferUtil.EMPTY_BUFFER);
  }
  catch (IOException x)
  {
    LOG.debug(x);
    close();
    return -1;
  }
}

protected ByteBuffer getMappedBuffer(Resource resource)
{
  // Only use file mapped buffers for cached resources, otherwise too much virtual memory commitment for
  // a non shared resource.  Also ignore max buffer size
  try
  {
    if (_useFileMappedBuffer && resource.getFile()!=null && resource.length()<Integer.MAX_VALUE) 
      return BufferUtil.toMappedBuffer(resource.getFile());            
  }
  catch(IOException|IllegalArgumentException e)
  {
    LOG.warn(e);
  }
  return null;
}

public DefaultHandler()
{
  try
  {
    URL fav = this.getClass().getClassLoader().getResource("org/eclipse/jetty/favicon.ico");
    if (fav!=null)
    {
      Resource r = Resource.newResource(fav);
      _favicon=IO.readBytes(r.getInputStream());
    }
  }
  catch(Exception e)
  {
    LOG.warn(e);
  }
}

/**
 * @param resourceBase
 *            The base resource as a string.
 */
public void setResourceBase(String resourceBase)
{
  try
  {
    setBaseResource(Resource.newResource(resourceBase));
  }
  catch (Exception e)
  {
    LOG.warn(e.toString());
    LOG.debug(e);
    throw new IllegalArgumentException(resourceBase);
  }
}

public void handle(HttpChannel channel) throws IOException, ServletException
{
  final String target=channel.getRequest().getPathInfo();
  final Request request=channel.getRequest();
  final Response response=channel.getResponse();
  if (LOG.isDebugEnabled())
    LOG.debug("{} {} {} on {}", request.getDispatcherType(), request.getMethod(), target, channel);
  if (HttpMethod.OPTIONS.is(request.getMethod()) || "*".equals(target))
  {
    if (!HttpMethod.OPTIONS.is(request.getMethod()))
      response.sendError(HttpStatus.BAD_REQUEST_400);
    handleOptions(request,response);
    if (!request.isHandled())
      handle(target, request, request, response);
  }
  else
    handle(target, request, request, response);
  if (LOG.isDebugEnabled())
    LOG.debug("handled={} async={} committed={} on {}", request.isHandled(),request.isAsyncStarted(),response.isCommitted(),channel);
}

public Resource getResource(String path) throws MalformedURLException
{
  if (path == null || !path.startsWith(URIUtil.SLASH))
    throw new MalformedURLException(path);
  if (_baseResource == null)
    return null;
  try
  {
    path = URIUtil.canonicalPath(path);
    Resource resource = _baseResource.addPath(path);
    if (checkAlias(path,resource))
      return resource;
    return null;
  }
  catch (Exception e)
  {
    LOG.ignore(e);
  }
  return null;
}

protected void commit (MetaData.Response info)
{
  _committedMetaData=info;
  if (LOG.isDebugEnabled())
    LOG.debug("COMMIT for {} on {}{}{} {} {}{}{}",getRequest().getRequestURI(),this,System.lineSeparator(),
        info.getStatus(),info.getReason(),info.getHttpVersion(),System.lineSeparator(),
        info.getFields());
}

public void onRequest(MetaData.Request request)
{
  _requests.incrementAndGet();
  _request.setTimeStamp(System.currentTimeMillis());
  HttpFields fields = _response.getHttpFields();
  if (_configuration.getSendDateHeader() && !fields.contains(HttpHeader.DATE))
    fields.put(_connector.getServer().getDateField());
  long idleTO=_configuration.getIdleTimeout();
  _oldIdleTimeout=getIdleTimeout();
  if (idleTO>=0 && _oldIdleTimeout!=idleTO)
    setIdleTimeout(idleTO);
  request.setTrailerSupplier(_trailerSupplier);
  _request.setMetaData(request);
  _request.setSecure(HttpScheme.HTTPS.is(request.getURI().getScheme()));
  notifyRequestBegin(_request);
  if (LOG.isDebugEnabled())
    LOG.debug("REQUEST for {} on {}{}{} {} {}{}{}",request.getURIString(),this,System.lineSeparator(),
        request.getMethod(),request.getURIString(),request.getHttpVersion(),System.lineSeparator(),
        request.getFields());
}

@Override
public InputStream getResourceAsStream(String path)
{
  try
  {
    URL url = getResource(path);
    if (url == null)
      return null;
    Resource r = Resource.newResource(url);
    // Cannot serve directories as an InputStream
    if(r.isDirectory())
      return null;
    return r.getInputStream();
  }
  catch (Exception e)
  {
    LOG.ignore(e);
    return null;
  }
}

public void handleAsync(HttpChannel channel) throws IOException, ServletException
{
  final HttpChannelState state = channel.getRequest().getHttpChannelState();
  final AsyncContextEvent event = state.getAsyncContextEvent();
  final Request baseRequest=channel.getRequest();
  final String path=event.getPath();
  if (path!=null)
  {
    // this is a dispatch with a path
    ServletContext context=event.getServletContext();
    String query=baseRequest.getQueryString();
    baseRequest.setURIPathQuery(URIUtil.addEncodedPaths(context==null?null:URIUtil.encodePath(context.getContextPath()), path));
    HttpURI uri = baseRequest.getHttpURI();
    baseRequest.setPathInfo(uri.getDecodedPath());
    if (uri.getQuery()!=null)
      baseRequest.mergeQueryParameters(query,uri.getQuery(), true); //we have to assume dispatch path and query are UTF8
  }
  final String target=baseRequest.getPathInfo();
  final HttpServletRequest request=(HttpServletRequest)event.getSuppliedRequest();
  final HttpServletResponse response=(HttpServletResponse)event.getSuppliedResponse();
  if (LOG.isDebugEnabled())
    LOG.debug("{} {} {} on {}", request.getDispatcherType(), request.getMethod(), target, channel);
  handle(target, baseRequest, request, response);
  if (LOG.isDebugEnabled())
    LOG.debug("handledAsync={} async={} committed={} on {}", channel.getRequest().isHandled(),request.isAsyncStarted(),response.isCommitted(),channel);
}

public Set<String> getResourcePaths(String path)
{
  try
  {
    path = URIUtil.canonicalPath(path);
    Resource resource = getResource(path);
    if (resource != null && resource.exists())
    {
      if (!path.endsWith(URIUtil.SLASH))
        path = path + URIUtil.SLASH;
      String[] l = resource.list();
      if (l != null)
      {
        HashSet<String> set = new HashSet<String>();
        for (int i = 0; i < l.length; i++)
          set.add(path + l[i]);
        return set;
      }
    }
  }
  catch (Exception e)
  {
    LOG.ignore(e);
  }
  return Collections.emptySet();
}

public HttpChannel(Connector connector, HttpConfiguration configuration, EndPoint endPoint, HttpTransport transport)
{
  _connector = connector;
  _configuration = configuration;
  _endPoint = endPoint;
  _transport = transport;
  _state = new HttpChannelState(this);
  _request = new Request(this, newHttpInput(_state));
  _response = new Response(this, newHttpOutput());
  _executor = connector == null ? null : connector.getServer().getThreadPool();
  _requestLog = connector == null ? null : connector.getServer().getRequestLog();
  List<Listener> listeners = new ArrayList<>();
  if (connector != null)
    listeners.addAll(connector.getBeans(Listener.class));
  _listeners = listeners;
  if (LOG.isDebugEnabled())
    LOG.debug("new {} -> {},{},{}",
        this,
        _endPoint,
        _endPoint==null?null:_endPoint.getConnection(),
        _state);
}

if (context.getContextPath()!=null && context.getContextPath().length()>0)
  int idx = context.getContextPath().lastIndexOf('/');
  name = idx < 0 ? context.getContextPath() : context.getContextPath().substring(++idx);
  if (name==null || name.length()==0)
    if (context.getBaseResource().getFile()!=null)
      name = context.getBaseResource().getFile().getName();
    LOG.ignore(e);
    name=context.getBaseResource().getName();

if (LOG.isDebugEnabled())
  LOG.debug("sendResponse info={} content={} complete={} committing={} callback={}",
      info,
      BufferUtil.toDetailString(content),
      complete,
      committing,
    info = _response.newResponseMetaData();
  commit(info);
  final Callback committed = (status<200&&status>=100)?new Commit100Callback(callback):new CommitCallback(callback, content, complete);
  notifyResponseBegin(_request);
  _transport.send(info, _request.isHead(), content, complete, committed);
  _transport.send(null,_request.isHead(), content, complete, new ContentCallback(callback, content, complete));

HttpField host = metadata==null?null:metadata.getFields().getField(HttpHeader.HOST);
if (host!=null)
String name=getLocalName();
if (name != null)
  return name;
  LOG.ignore(e);