docs: @Override
      @FFDCIgnore(IOException.class)
      public void error(VirtualConnection vc, TCPReadRequestContext rsc, IOException ioe) {
          boolean closing = false;
          boolean isFirstRead = false;
          synchronized(_srtUpgradeStream){
              closing = _upgradeStream.isClosing();
              isFirstRead = _upgradeStream.isFirstRead();
              _upgradeStream.setIsInitialRead(false);
          }
          if(!closing){
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "Encountered an error during the initial read for data : " + ioe + ", " + _rl);
              }
  
              try{
                  //Set the original Context Class Loader before calling the users onDataAvailable
                  //Push the original thread's context onto the current thread, also save off the current thread's context
                  _contextManager.pushContextData();
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                      Tr.debug(tc, "Error encountered while we are not closing : " + _rl);
                  }
  
                  if(!isFirstRead){
                      if(WCCustomProperties31.UPGRADE_READ_TIMEOUT != TCPReadRequestContext.NO_TIMEOUT && ioe instanceof SocketTimeoutException){
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                              Tr.debug(tc, "Other side did not send data within the timeout time, calling onError : " + _rl);
                          }
                          if(! _upgradeStream.isIsonErrorCalled()) {
                              _upgradeStream.setIsonErrorCalled(true);
                              _rl.onError(ioe);
                          }
                      } else {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                              Tr.debug(tc, "Other side must be closed, check if not called before call onAllDataRead : " + _rl);
                          }
                          if(! _upgradeStream.isAlldataReadCalled()) {
                              try{
                                  //We will call onAllDataRead if we encounter the error because we assume the other side has closed the connection since there is no timeout currently
                                  //The other side closing the connection means that we have read all the data
                                  _upgradeStream.setAlldataReadCalled(true);
                                  _rl.onAllDataRead();
  
                              } catch(Throwable onAllDataReadException){
                                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                                      Tr.debug(tc, "Encountered an error during ReadListener.onAllDataRead : " + onAllDataReadException + ", " + _rl);
                                  }
                                  if(! _upgradeStream.isIsonErrorCalled()) {
                                      _upgradeStream.setIsonErrorCalled(true);                                
                                      _rl.onError(onAllDataReadException);
                                  }
                              }
                          }
                      }
                  } else {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "Encountered an error during the first initialRead for data, calling the ReadListener.onError : " + _rl);
                      }
                      if (TraceComponent.isAnyTracingEnabled() && tc.isErrorEnabled())
                          Tr.error(tc, "setReadListener.initialread.failed");
  
                      if(! _upgradeStream.isIsonErrorCalled()) {
                          _upgradeStream.setIsonErrorCalled(true);
                          _rl.onError(ioe);
                      }
                  }
              } finally {
                  try {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "finally call close from ReadListener.onError : " + _rl);
                      }
                      _upgradeStream.getWebConn().close();
                  } catch( Exception e ) {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "Caught exception during WebConnection.close : " + e + "," + _rl);
                      }
                  }
  
                  //Revert back to the thread's current context
                  _contextManager.popContextData();
              }
          } else {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "We are closing, skipping the call to onError");
              }
              synchronized(_srtUpgradeStream){
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                      Tr.debug(tc, "Issuing the notify");
                  }
                  _srtUpgradeStream.notify();
              }
          }
      }