How to use

HttpEventListenerWrapper

in

org.eclipse.jetty.client

@Override
public void onRequestComplete() throws IOException
{
  _requestComplete = true;
  if (checkExchangeComplete())
  {
    super.onRequestComplete();
  }
}

@Override
public void onResponseComplete() throws IOException
{
  _responseComplete = true;
  if (checkExchangeComplete())
  {
    super.onResponseComplete();
  }
}

@Override
public void onResponseHeader( Buffer name, Buffer value )
  throws IOException
{
  if (_redirected)
  {
    int header = HttpHeaders.CACHE.getOrdinal(name);
    switch (header)
    {
      case HttpHeaders.LOCATION_ORDINAL:
        _location = value.toString();
        break;
    }
  }
  super.onResponseHeader(name,value);
}

@Override
public void onResponseStatus( final Buffer version, final int status, final Buffer reason )
  throws IOException
{
  _unAuthorized = ( status == HttpStatus.UNAUTHORIZED_401 );
  if ( _unAuthorized )
  {
    setDelegatingRequests( false );
    setDelegatingResponses( false );
  }
  super.onResponseStatus( version, status, reason );
}

public void onRetry()
{
  _redirected=false;
  _attempts++;
  setDelegatingRequests(true);
  setDelegatingResponses(true);
  _requestComplete=false;
  _responseComplete=false;
  super.onRetry();
}

  /**
   * Delegate onException
   */
  @Override
  public void onException( Throwable ex )
  {
    setDelegatingRequests(true);
    setDelegatingResponses(true);

    super.onException( ex );
  }
}

/**
 * Delegate failed connection
 */
@Override
public void onConnectionFailed( Throwable ex )
{
  setDelegatingRequests(true);
  setDelegatingResponses(true);
  super.onConnectionFailed( ex );
}

while(listener instanceof HttpEventListenerWrapper)
  listener=((HttpEventListenerWrapper)listener).getEventListener();

@Override
public void onResponseStatus( Buffer version, int status, Buffer reason )
  throws IOException
{
  _redirected = ((status == HttpStatus.MOVED_PERMANENTLY_301 ||
          status == HttpStatus.MOVED_TEMPORARILY_302) &&
          _attempts < _destination.getHttpClient().maxRedirects());
  if (_redirected)
  {
    setDelegatingRequests(false);
    setDelegatingResponses(false);
  }
  super.onResponseStatus(version,status,reason);
}

@Override
public void onRetry()
{
  _attempts++;
  setDelegatingRequests(true);
  setDelegatingResponses(true);
  _requestComplete=false;
  _responseComplete=false;
  _needIntercept=false;
  super.onRetry();
}  

@Override
public void onRequestComplete()
  throws IOException
{
  _requestComplete = true;
  checkExchangeComplete();
  super.onRequestComplete();
}

@Override
public void onResponseComplete()
  throws IOException
{
  _responseComplete = true;
  checkExchangeComplete();
  super.onResponseComplete();
}

  super.onResponseStatus(version, status, reason);
  return;
super.onResponseStatus(version, status, reason);

@Override
public void onResponseHeader( final Buffer name, final Buffer value )
  throws IOException
{
  if ( _unAuthorized )
  {
    int header = HttpHeaders.CACHE.getOrdinal( name );
    switch ( header )
    {
      case HttpHeaders.WWW_AUTHENTICATE_ORDINAL:
        String authString = value.toString();
        _authTypes.add( scrapeAuthenticationType( authString ) );
        break;
    }
  }
  super.onResponseHeader( name, value );
}

      super.onRequestComplete();
    super.onRequestComplete();
  super.onRequestComplete();
super.onRequestComplete();

      setDelegatingRequests( true );
      setDelegatingResponses(true);
      super.onResponseComplete();
    super.onResponseComplete();
  super.onResponseComplete();
super.onResponseComplete();

@Override
public void onResponseStatus( Buffer version, int status, Buffer reason )
  throws IOException
{
  if (LOG.isDebugEnabled())
    LOG.debug("SecurityListener:Response Status: " + status );
  if ( status == HttpStatus.UNAUTHORIZED_401 && _attempts<_destination.getHttpClient().maxRetries()) 
  {
    // Let's absorb events until we have done some retries
    setDelegatingResponses(false);
    _needIntercept = true;
  }
  else 
  {
    setDelegatingResponses(true);
    setDelegatingRequests(true);
    _needIntercept = false;
  }
  super.onResponseStatus(version,status,reason);
}

super.onResponseHeader(name,value);

@Override
public void onRequestComplete() throws IOException
{
  _requestComplete = true;
  if (_needIntercept)
  {
    if (_requestComplete && _responseComplete)
    {
      if (LOG.isDebugEnabled())
        LOG.debug("onRequestComplete, Both complete: Resending from onResponseComplete "+_exchange); 
      _responseComplete = false;
      _requestComplete = false;
      setDelegatingRequests(true);
      setDelegatingResponses(true);
      _destination.resend(_exchange);  
    } 
    else
    {
      if (LOG.isDebugEnabled())
        LOG.debug("onRequestComplete, Response not yet complete onRequestComplete, calling super for "+_exchange);
      super.onRequestComplete(); 
    }
  }
  else
  {
    if (LOG.isDebugEnabled())
      LOG.debug("onRequestComplete, delegating to super with Request complete="+_requestComplete+", response complete="+_responseComplete+" "+_exchange);
    super.onRequestComplete();
  }
}

@Override
public void onResponseComplete() throws IOException
{   
  _responseComplete = true;
  if (_needIntercept)
  {  
    if (_requestComplete && _responseComplete)
    {              
      if (LOG.isDebugEnabled())
        LOG.debug("onResponseComplete, Both complete: Resending from onResponseComplete"+_exchange);
      _responseComplete = false;
      _requestComplete = false;
      setDelegatingResponses(true);
      setDelegatingRequests(true);
      _destination.resend(_exchange); 
    }
    else
    {
      if (LOG.isDebugEnabled())
        LOG.debug("onResponseComplete, Request not yet complete from onResponseComplete,  calling super "+_exchange);
      super.onResponseComplete(); 
    }
  }
  else
  {
    if (LOG.isDebugEnabled())
      LOG.debug("OnResponseComplete, delegating to super with Request complete="+_requestComplete+", response complete="+_responseComplete+" "+_exchange);
    super.onResponseComplete();  
  }
}