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

@Override
protected void doStart() throws Exception
{
  if (LOG.isDebugEnabled())
    LOG.debug("starting {}",this);
  if (_server==null)
    LOG.warn("No Server set for {}",this);
  super.doStart();
}

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

void releaseRequestBuffer()
{
  if (_requestBuffer != null && !_requestBuffer.hasRemaining())
  {
    if (LOG.isDebugEnabled())
      LOG.debug("releaseRequestBuffer {}",this);
    ByteBuffer buffer=_requestBuffer;
    _requestBuffer=null;
    _bufferPool.release(buffer);
  }
}

public boolean isExpiredAt (long time)
{
  if (LOG.isDebugEnabled())
    LOG.debug("Testing expiry on session {}: expires at {} now {} maxIdle {}", _id, getExpiry(), time, getMaxInactiveMs());
  if (getMaxInactiveMs() <= 0)
    return false; //never expires
  return (getExpiry() <= time);
}

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();
}

  protected void updateBean(String name,Object oldBean,Object newBean)
  {
    LOG.info("update {} {}->{} on {}",name,oldBean,newBean,_context);
    if (LOG.isDebugEnabled())
      LOG.debug("update {} {}->{} on {}",name,oldBean,newBean,_context);
    _context.updateBean(oldBean,newBean,false);
  }
}

@Override
protected void accept(int acceptorID) throws IOException, InterruptedException
{
  if (LOG.isDebugEnabled())
    LOG.debug("accepting {}", acceptorID);
  LocalEndPoint endPoint = _connects.take();
  Connection connection = getDefaultConnectionFactory().newConnection(this, endPoint);
  endPoint.setConnection(connection);
  
  endPoint.onOpen();
  onEndPointOpened(endPoint);
  connection.onOpen();
}

private void setError(Throwable th)
{
  super.setError();
  if (th instanceof IOException)
    _ioException=(IOException)th;
  else
  {
    _ioException=new IOException(String.valueOf(th));
    _ioException.initCause(th);
  }
  if (LOG.isDebugEnabled())
    LOG.debug(th);
}

public void errorComplete()
{
  try(Locker.Lock lock= _locker.lock())
  {
    if (LOG.isDebugEnabled())
      LOG.debug("error complete {}",toStringLocked());
    
    _async=Async.COMPLETE;
    _event.setDispatchContext(null);
    _event.setDispatchPath(null);
  }
  cancelTimeout();
}

public boolean sendResponse(MetaData.Response info, ByteBuffer content, boolean complete) throws IOException
{
  try(Blocker blocker = _response.getHttpOutput().acquireWriteBlockingCallback())
  {
    boolean committing = sendResponse(info,content,complete,blocker);
    blocker.block();
    return committing;
  }
  catch (Throwable failure)
  {
    if (LOG.isDebugEnabled())
      LOG.debug(failure);
    abort(failure);
    throw failure;
  }
}

protected void notFound(Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
{
  if (LOG.isDebugEnabled())
    LOG.debug("Not Found {}",request.getRequestURI());
  if (getHandler()!=null)
    nextHandle(URIUtil.addPaths(request.getServletPath(),request.getPathInfo()),baseRequest,request,response);
}

public void waitUntilClosedOrIdleFor(long idleFor,TimeUnit units)
{
  Thread.yield();
  int size=getOutput().remaining();
  while (isOpen())
  {
    try
    {
      if (!_closed.await(idleFor,units))
      {
        if (size==getOutput().remaining())
        {
          if (LOG.isDebugEnabled())
            LOG.debug("idle for {} {}",idleFor,units);
          return;
        }
        size=getOutput().remaining();
      }
    }
    catch(Exception e)
    {
      LOG.warn(e);
    }
  }
}

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());
}

if (LOG.isDebugEnabled()) LOG.debug("Sweeping {} for old session files", _storeDir);
try
      LOG.warn(e);
  LOG.warn(e);

/** 
 * @see org.eclipse.jetty.io.IdleTimeout#onIdleExpired(java.util.concurrent.TimeoutException)
 */
@Override
protected void onIdleExpired(TimeoutException timeout)
{
  //called when the timer goes off
  if (LOG.isDebugEnabled()) LOG.debug("Timer expired for session {}", getId());
  getSessionHandler().sessionInactivityTimerExpired(Session.this);
}

public HttpConnection(HttpConfiguration config, Connector connector, EndPoint endPoint, HttpCompliance compliance, boolean recordComplianceViolations)
{
  super(endPoint, connector.getExecutor());
  _config = config;
  _connector = connector;
  _bufferPool = _connector.getByteBufferPool();
  _generator = newHttpGenerator();
  _channel = newHttpChannel();
  _input = _channel.getRequest().getHttpInput();
  _parser = newHttpParser(compliance);
  _recordHttpComplianceViolations = recordComplianceViolations;
  if (LOG.isDebugEnabled())
    LOG.debug("New HTTP Connection {}", this);
}

public void adaptTo(DatabaseMetaData dbMeta)  
throws SQLException
{
  _dbName = dbMeta.getDatabaseProductName().toLowerCase(Locale.ENGLISH);
  if (LOG.isDebugEnabled())
    LOG.debug ("Using database {}",_dbName);
  _isLower = dbMeta.storesLowerCaseIdentifiers();
  _isUpper = dbMeta.storesUpperCaseIdentifiers(); 
}

private void extractQueryParameters()
{
  MetaData.Request metadata = _metaData;
  if (metadata==null || metadata.getURI() == null || !metadata.getURI().hasQuery())
    _queryParameters=NO_PARAMS;
  else
  {
    _queryParameters = new MultiMap<>();
    if (_queryEncoding == null)
      metadata.getURI().decodeQueryTo(_queryParameters);
    else
    {
      try
      {
        metadata.getURI().decodeQueryTo(_queryParameters, _queryEncoding);
      }
      catch (UnsupportedEncodingException e)
      {
        if (LOG.isDebugEnabled())
          LOG.warn(e);
        else
          LOG.warn(e.toString());
      }
    }
  }
}

protected void sendError(int code, String reason)
{
  try
  {
    _response.sendError(code, reason);
  }
  catch (Throwable x)
  {
    if (LOG.isDebugEnabled())
      LOG.debug("Could not send error " + code + " " + reason, x);
  }
  finally
  {
    _state.errorComplete();
  }
}

@SuppressWarnings("unchecked")
@Override
public void doStart()
  throws Exception
{
  //if no class already loaded and no classname, make permanently unavailable
  if (_class==null && (_className==null || _className.equals("")))
    throw new UnavailableException("No class in holder "+toString());
  
  //try to load class
  if (_class==null)
  {
    try
    {
      _class=Loader.loadClass(_className);
      if(LOG.isDebugEnabled())
        LOG.debug("Holding {} from {}",_class,_class.getClassLoader());
    }
    catch (Exception e)
    {
      LOG.warn(e);
      throw new UnavailableException("Class loading error for holder "+toString());
    }
  }
}