xrootd
XrdClXRootDMsgHandler.hh
Go to the documentation of this file.
1 //------------------------------------------------------------------------------
2 // Copyright (c) 2011-2014 by European Organization for Nuclear Research (CERN)
3 // Author: Lukasz Janyst <ljanyst@cern.ch>
4 //------------------------------------------------------------------------------
5 // This file is part of the XRootD software suite.
6 //
7 // XRootD is free software: you can redistribute it and/or modify
8 // it under the terms of the GNU Lesser General Public License as published by
9 // the Free Software Foundation, either version 3 of the License, or
10 // (at your option) any later version.
11 //
12 // XRootD is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16 //
17 // You should have received a copy of the GNU Lesser General Public License
18 // along with XRootD. If not, see <http://www.gnu.org/licenses/>.
19 //
20 // In applying this licence, CERN does not waive the privileges and immunities
21 // granted to it by virtue of its status as an Intergovernmental Organization
22 // or submit itself to any jurisdiction.
23 //------------------------------------------------------------------------------
24 
25 #ifndef __XRD_CL_XROOTD_MSG_HANDLER_HH__
26 #define __XRD_CL_XROOTD_MSG_HANDLER_HH__
27 
30 #include "XrdCl/XrdClDefaultEnv.hh"
31 #include "XrdCl/XrdClMessage.hh"
32 #include "XProtocol/XProtocol.hh"
33 #include "XrdCl/XrdClLog.hh"
34 #include "XrdCl/XrdClConstants.hh"
35 
36 #include "XrdSys/XrdSysPthread.hh"
37 #include "XrdSys/XrdSysPageSize.hh"
39 
40 #include <sys/uio.h>
41 #include <arpa/inet.h> // for network unmarshaling stuff
42 
43 #include <array>
44 #include <list>
45 #include <memory>
46 
47 #include <atomic>
48 
49 namespace XrdCl
50 {
51  class PostMaster;
52  class SIDManager;
53  class URL;
54  class LocalFileHandler;
55  class Socket;
56 
57  //----------------------------------------------------------------------------
58  // Single entry in the redirect-trace-back
59  //----------------------------------------------------------------------------
61  {
62  enum Type
63  {
67  EntryWait
68  };
69 
70  RedirectEntry( const URL &from, const URL &to, Type type ) :
71  from( from ), to( to ), type( type )
72  {
73 
74  }
75 
80 
81  std::string ToString( bool prevok = true )
82  {
83  const std::string tostr = to.GetLocation();
84  const std::string fromstr = from.GetLocation();
85 
86  if( prevok )
87  {
88  switch( type )
89  {
90  case EntryRedirect: return "Redirected from: " + fromstr + " to: "
91  + tostr;
92 
93  case EntryRedirectOnWait: return "Server responded with wait. "
94  "Falling back to virtual redirector: " + tostr;
95 
96  case EntryRetry: return "Retrying: " + tostr;
97 
98  case EntryWait: return "Waited at server request. Resending: "
99  + tostr;
100  }
101  }
102  return "Failed at: " + fromstr + ", retrying at: " + tostr;
103  }
104  };
105 
106  //----------------------------------------------------------------------------
108  //----------------------------------------------------------------------------
110  public OutgoingMsgHandler
111  {
112  friend class HandleRspJob;
113 
114  public:
115  //------------------------------------------------------------------------
124  //------------------------------------------------------------------------
126  ResponseHandler *respHandler,
127  const URL *url,
128  std::shared_ptr<SIDManager> sidMgr,
129  LocalFileHandler *lFileHandler):
130  pRequest( msg ),
131  pResponse( 0 ),
132  pResponseHandler( respHandler ),
133  pUrl( *url ),
135  pSidMgr( sidMgr ),
136  pLFileHandler( lFileHandler ),
137  pExpiration( 0 ),
138  pRedirectAsAnswer( false ),
139  pOksofarAsAnswer( false ),
140  pHosts( 0 ),
141  pHasLoadBalancer( false ),
142  pHasSessionId( false ),
143  pChunkList( 0 ),
144  pRedirectCounter( 0 ),
146 
147  pAsyncOffset( 0 ),
148  pAsyncChunkOffset( 0 ),
149  pAsyncChunkIndex( 0 ),
150  pAsyncReadSize( 0 ),
151  pAsyncReadBuffer( 0 ),
152  pAsyncMsgSize( 0 ),
153 
154  pReadRawStarted( false ),
156 
157  pReadVRawMsgOffset( 0 ),
158  pReadVRawChunkHeaderDone( false ),
160  pReadVRawSizeError( false ),
161  pReadVRawChunkIndex( 0 ),
162  pReadVRawMsgDiscard( false ),
163 
164  pOtherRawStarted( false ),
165 
166  pFollowMetalink( false ),
167 
168  pStateful( false ),
169 
170  pAggregatedWaitTime( 0 ),
171 
172  pMsgInFly( false ),
173 
174  pTimeoutFence( false ),
175 
176  pDirListStarted( false ),
177  pDirListWithStat( false ),
178 
179  pCV( 0 ),
180 
181  pSslErrCnt( 0 )
182 
183  {
185  if( msg->GetSessionId() )
186  pHasSessionId = true;
187  memset( &pReadVRawChunkHeader, 0, sizeof( readahead_list ) );
188 
189  Log *log = DefaultEnv::GetLog();
190  log->Debug( ExDbgMsg, "[%s] MsgHandler created: 0x%x (message: %s ).",
191  pUrl.GetHostId().c_str(), this,
192  pRequest->GetDescription().c_str() );
193 
195  if( ntohs( hdr->requestid ) == kXR_pgread )
196  {
198  pPgReadCksums.reserve( NbPages( ntohl( pgrdreq->rlen ) ) );
199  }
200  }
201 
202  //------------------------------------------------------------------------
204  //------------------------------------------------------------------------
206  {
208 
209  if( !pHasSessionId )
210  delete pRequest;
211  delete pResponse;
212  std::vector<Message *>::iterator it;
213  for( it = pPartialResps.begin(); it != pPartialResps.end(); ++it )
214  delete *it;
215 
217 
218  pRequest = reinterpret_cast<Message*>( 0xDEADBEEF );
219  pResponse = reinterpret_cast<Message*>( 0xDEADBEEF );
220  pResponseHandler = reinterpret_cast<ResponseHandler*>( 0xDEADBEEF );
221  pPostMaster = reinterpret_cast<PostMaster*>( 0xDEADBEEF );
222  pLFileHandler = reinterpret_cast<LocalFileHandler*>( 0xDEADBEEF );
223  pHosts = reinterpret_cast<HostList*>( 0xDEADBEEF );
224  pChunkList = reinterpret_cast<ChunkList*>( 0xDEADBEEF );
225  pEffectiveDataServerUrl = reinterpret_cast<URL*>( 0xDEADBEEF );
226 
227  Log *log = DefaultEnv::GetLog();
228  log->Debug( ExDbgMsg, "[%s] Destroying MsgHandler: 0x%x.",
229  pUrl.GetHostId().c_str(), this );
230  }
231 
232  //------------------------------------------------------------------------
238  //------------------------------------------------------------------------
239  virtual uint16_t Examine( Message *msg );
240 
241  //------------------------------------------------------------------------
250  //------------------------------------------------------------------------
251  virtual uint16_t InspectStatusRsp( Message *msg );
252 
253  //------------------------------------------------------------------------
257  //------------------------------------------------------------------------
258  virtual uint16_t GetSid() const;
259 
260  //------------------------------------------------------------------------
264  //------------------------------------------------------------------------
265  virtual void Process( Message *msg );
266 
267  //------------------------------------------------------------------------
277  //------------------------------------------------------------------------
279  Socket *socket,
280  uint32_t &bytesRead );
281 
282  //------------------------------------------------------------------------
288  //------------------------------------------------------------------------
289  virtual uint8_t OnStreamEvent( StreamEvent event,
290  XRootDStatus status );
291 
292  //------------------------------------------------------------------------
294  //------------------------------------------------------------------------
295  virtual void OnStatusReady( const Message *message,
296  XRootDStatus status );
297 
298  //------------------------------------------------------------------------
300  //------------------------------------------------------------------------
301  virtual bool IsRaw() const;
302 
303  //------------------------------------------------------------------------
312  //------------------------------------------------------------------------
314  uint32_t &bytesWritten );
315 
316  //------------------------------------------------------------------------
320  //------------------------------------------------------------------------
321  void WaitDone( time_t now );
322 
323  //------------------------------------------------------------------------
325  //------------------------------------------------------------------------
326  void SetExpiration( time_t expiration )
327  {
328  pExpiration = expiration;
329  }
330 
331  //------------------------------------------------------------------------
334  //------------------------------------------------------------------------
335  void SetRedirectAsAnswer( bool redirectAsAnswer )
336  {
337  pRedirectAsAnswer = redirectAsAnswer;
338  }
339 
340  //------------------------------------------------------------------------
343  //------------------------------------------------------------------------
344  void SetOksofarAsAnswer( bool oksofarAsAnswer )
345  {
346  pOksofarAsAnswer = oksofarAsAnswer;
347  }
348 
349  //------------------------------------------------------------------------
351  //------------------------------------------------------------------------
352  const Message *GetRequest() const
353  {
354  return pRequest;
355  }
356 
357  //------------------------------------------------------------------------
359  //------------------------------------------------------------------------
360  void SetLoadBalancer( const HostInfo &loadBalancer )
361  {
362  if( !loadBalancer.url.IsValid() )
363  return;
364  pLoadBalancer = loadBalancer;
365  pHasLoadBalancer = true;
366  }
367 
368  //------------------------------------------------------------------------
370  //------------------------------------------------------------------------
371  void SetHostList( HostList *hostList )
372  {
373  delete pHosts;
374  pHosts = hostList;
375  }
376 
377  //------------------------------------------------------------------------
379  //------------------------------------------------------------------------
380  void SetChunkList( ChunkList *chunkList )
381  {
382  pChunkList = chunkList;
383  if( chunkList )
384  pChunkStatus.resize( chunkList->size() );
385  else
386  pChunkStatus.clear();
387  }
388 
389  //------------------------------------------------------------------------
391  //------------------------------------------------------------------------
393  {
394  pKBuff = kbuff;
395  }
396 
397  //------------------------------------------------------------------------
399  //------------------------------------------------------------------------
400  void SetRedirectCounter( uint16_t redirectCounter )
401  {
402  pRedirectCounter = redirectCounter;
403  }
404 
405  void SetFollowMetalink( bool followMetalink )
406  {
407  pFollowMetalink = followMetalink;
408  }
409 
410  void SetStateful( bool stateful )
411  {
412  pStateful = stateful;
413  }
414 
415  //------------------------------------------------------------------------
417  //------------------------------------------------------------------------
419 
420  private:
421 
422  //------------------------------------------------------------------------
424  //------------------------------------------------------------------------
426  Socket *socket,
427  uint32_t &bytesRead );
428 
429  //------------------------------------------------------------------------
431  //------------------------------------------------------------------------
433  Socket *socket,
434  uint32_t &bytesRead );
435 
436  //------------------------------------------------------------------------
438  //------------------------------------------------------------------------
440  Socket *socket,
441  uint32_t &bytesRead );
442 
443  //------------------------------------------------------------------------
445  //------------------------------------------------------------------------
447  Socket *socket,
448  uint32_t &bytesRead );
449 
450  //------------------------------------------------------------------------
453  //------------------------------------------------------------------------
454  inline Status ReadAsync( Socket *socket, uint32_t &bytesRead )
455  {
456  uint32_t toBeRead = pAsyncReadSize - pAsyncOffset;
457  uint32_t btsRead = 0;
458  Status st = ReadBytesAsync( socket, pAsyncReadBuffer, toBeRead, btsRead );
459  pAsyncOffset += btsRead;
460  bytesRead += btsRead;
461  return st;
462  }
463 
464  //------------------------------------------------------------------------
467  //------------------------------------------------------------------------
468  inline Status ReadPagesAsync( Socket *socket, uint32_t &bytesRead )
469  {
470  uint32_t toBeRead = pAsyncReadSize - pAsyncOffset;
471  while( toBeRead > 0 )
472  {
473  uint32_t btsRead = 0;
474  Status st = ReadPageAsync( socket, btsRead );
475  if( !st.IsOK() || st.code == suRetry ) return st;
476  bytesRead += btsRead;
477  toBeRead -= btsRead;
478  }
479 
480  return Status();
481  }
482 
483  //------------------------------------------------------------------------
486  //------------------------------------------------------------------------
487  Status ReadPageAsync( Socket *socket, uint32_t &bytesRead );
488 
489  //------------------------------------------------------------------------
491  //------------------------------------------------------------------------
492  static Status ReadBytesAsync( Socket *socket, char *&buffer,
493  uint32_t toBeRead, uint32_t &bytesRead );
494 
495  //------------------------------------------------------------------------
497  //------------------------------------------------------------------------
498  void HandleError( XRootDStatus status, Message *msg = 0 );
499 
500  //------------------------------------------------------------------------
502  //------------------------------------------------------------------------
503  Status RetryAtServer( const URL &url, RedirectEntry::Type entryType );
504 
505  //------------------------------------------------------------------------
507  //------------------------------------------------------------------------
509 
510  //------------------------------------------------------------------------
512  //------------------------------------------------------------------------
514 
515  //------------------------------------------------------------------------
518  //------------------------------------------------------------------------
520 
521  //------------------------------------------------------------------------
524  //------------------------------------------------------------------------
525  Status ParseXAttrResponse( char *data, size_t len, AnyObject *&response );
526 
527  //------------------------------------------------------------------------
530  //------------------------------------------------------------------------
532 
533  //------------------------------------------------------------------------
535  //------------------------------------------------------------------------
537 
538  //------------------------------------------------------------------------
540  //------------------------------------------------------------------------
542 
543  //------------------------------------------------------------------------
545  //------------------------------------------------------------------------
547 
548  //------------------------------------------------------------------------
550  //------------------------------------------------------------------------
551  void UpdateTriedCGI(uint32_t errNo=0);
552 
553  //------------------------------------------------------------------------
555  //------------------------------------------------------------------------
557 
558  //------------------------------------------------------------------------
561  //------------------------------------------------------------------------
563 
564  //------------------------------------------------------------------------
566  //------------------------------------------------------------------------
567  void HandleLocalRedirect( URL *url );
568 
569  //------------------------------------------------------------------------
574  //------------------------------------------------------------------------
575  bool IsRetriable( Message *request );
576 
577  //------------------------------------------------------------------------
584  //------------------------------------------------------------------------
585  bool OmitWait( Message *request, const URL &url );
586 
587  //------------------------------------------------------------------------
593  //------------------------------------------------------------------------
594  bool RetriableErrorResponse( const Status &status );
595 
596  //------------------------------------------------------------------------
598  //------------------------------------------------------------------------
600 
607  //------------------------------------------------------------------------
608  template<typename T>
609  Status ReadFromBuffer( char *&buffer, size_t &buflen, T& result );
610 
611  //------------------------------------------------------------------------
618  //------------------------------------------------------------------------
619  Status ReadFromBuffer( char *&buffer, size_t &buflen, std::string &result );
620 
621  //------------------------------------------------------------------------
629  //------------------------------------------------------------------------
630  Status ReadFromBuffer( char *&buffer, size_t &buflen, size_t size,
631  std::string &result );
632 
633  //------------------------------------------------------------------------
634  // Helper struct for async reading of chunks
635  //------------------------------------------------------------------------
636  struct ChunkStatus
637  {
638  ChunkStatus(): sizeError( false ), done( false ) {}
639  bool sizeError;
640  bool done;
641  };
642 
643  typedef std::list<std::unique_ptr<RedirectEntry>> RedirectTraceBack;
644 
645  static const size_t PageSize = XrdSys::PageSize;
646  static const size_t CksumSize = sizeof( uint32_t );
647  static const size_t PageWithCksum = PageSize + CksumSize;
648  static const size_t MaxSslErrRetry = 3;
649 
650  inline static size_t NbPages( uint32_t dlen )
651  {
652  size_t nbpages = dlen / PageWithCksum;
653  if( dlen % PageWithCksum ) ++nbpages;
654  return nbpages;
655  }
656 
657  inline void Copy( uint32_t offchlst, char *buffer, size_t length )
658  {
659  auto itr = pChunkList->begin();
660  while( length > 0 )
661  {
662  // first find the right buffer
663  char *dstbuf = nullptr;
664  size_t cplen = 0;
665  for( ; itr != pChunkList->end() ; ++itr )
666  {
667  if( offchlst < itr->offset ||
668  offchlst >= itr->offset + itr->length )
669  continue;
670  size_t dstoff = offchlst - itr->offset;
671  dstbuf = reinterpret_cast<char*>( itr->buffer ) + dstoff;
672  cplen = itr->length - cplen;
673  break;
674  }
675  // now do the copy
676  if( cplen > length ) cplen = length;
677  memcpy( dstbuf, buffer, cplen );
678  buffer += cplen;
679  length -= cplen;
680  }
681  }
682 
685  std::vector<Message *> pPartialResps;
690  std::shared_ptr<SIDManager> pSidMgr;
694  time_t pExpiration;
701  std::string pRedirectUrl;
704  std::vector<ChunkStatus> pChunkStatus;
707 
708  uint32_t pAsyncOffset;
711  uint32_t pAsyncReadSize;
713  uint32_t pAsyncMsgSize;
714 
717 
718  std::array<char, 4> pPgReadCksumBuff;
719  std::vector<uint32_t> pPgReadCksums;
720 
728 
730 
732 
733  bool pStateful;
735 
736  std::unique_ptr<RedirectEntry> pRdirEntry;
738 
739  bool pMsgInFly;
740 
741  //------------------------------------------------------------------------
742  // true if MsgHandler is both in inQueue and installed in respective
743  // Stream (this could happen if server gave oksofar response), otherwise
744  // false
745  //------------------------------------------------------------------------
746  std::atomic<bool> pTimeoutFence;
747 
748  //------------------------------------------------------------------------
749  // if we are serving chunked data to the user's handler in case of
750  // kXR_dirlist we need to memorize if the response contains stat info or
751  // not (the information is only encoded in the first chunk)
752  //------------------------------------------------------------------------
755 
756  //------------------------------------------------------------------------
757  // synchronization is needed in case the MsgHandler has been configured
758  // to serve kXR_oksofar as a response to the user's handler
759  //------------------------------------------------------------------------
761 
762  //------------------------------------------------------------------------
763  // Count of consecutive `errTlsSslError` errors
764  //------------------------------------------------------------------------
765  size_t pSslErrCnt;
766  };
767 }
768 
769 #endif // __XRD_CL_XROOTD_MSG_HANDLER_HH__
@ kXR_pgread
Definition: XProtocol.hh:141
Definition: XrdClAnyObject.hh:33
const char * GetBuffer(uint32_t offset=0) const
Get the message buffer.
Definition: XrdClBuffer.hh:72
static PostMaster * GetPostMaster()
Get default post master.
static Log * GetLog()
Get default log.
Message handler.
Definition: XrdClPostMasterInterfaces.hh:72
StreamEvent
Events that may have occurred to the stream.
Definition: XrdClPostMasterInterfaces.hh:99
Definition: XrdClLocalFileHandler.hh:33
Handle diagnostics.
Definition: XrdClLog.hh:101
void Debug(uint64_t topic, const char *format,...)
Print a debug message.
The message representation used throughout the system.
Definition: XrdClMessage.hh:30
const std::string & GetDescription() const
Get the description of the message.
Definition: XrdClMessage.hh:74
uint64_t GetSessionId() const
Get the session ID the message is meant for.
Definition: XrdClMessage.hh:90
Message status handler.
Definition: XrdClPostMasterInterfaces.hh:185
A hub for dispatching and receiving messages.
Definition: XrdClPostMaster.hh:48
Handle an async response.
Definition: XrdClXRootDResponses.hh:1051
A network socket.
Definition: XrdClSocket.hh:42
URL representation.
Definition: XrdClURL.hh:31
std::string GetHostId() const
Get the host part of the URL (user:password@host:port)
Definition: XrdClURL.hh:94
std::string GetLocation() const
Get location (protocol://host:port/path)
bool IsValid() const
Is the url valid.
Vector read info.
Definition: XrdClXRootDResponses.hh:986
Handle/Process/Forward XRootD messages.
Definition: XrdClXRootDMsgHandler.hh:111
void SetRedirectCounter(uint16_t redirectCounter)
Set the redirect counter.
Definition: XrdClXRootDMsgHandler.hh:400
Status ReadFromBuffer(char *&buffer, size_t &buflen, std::string &result)
bool pDirListStarted
Definition: XrdClXRootDMsgHandler.hh:753
Status UnPackReadVResponse(Message *msg)
Unpack a single readv response.
bool pHasLoadBalancer
Definition: XrdClXRootDMsgHandler.hh:698
XRootDStatus WriteMessageBody(Socket *socket, uint32_t &bytesWritten)
std::array< char, 4 > pPgReadCksumBuff
Definition: XrdClXRootDMsgHandler.hh:718
bool pMsgInFly
Definition: XrdClXRootDMsgHandler.hh:739
void SetFollowMetalink(bool followMetalink)
Definition: XrdClXRootDMsgHandler.hh:405
const Message * GetRequest() const
Get the request pointer.
Definition: XrdClXRootDMsgHandler.hh:352
void SetChunkList(ChunkList *chunkList)
Set the chunk list.
Definition: XrdClXRootDMsgHandler.hh:380
uint32_t pAsyncReadSize
Definition: XrdClXRootDMsgHandler.hh:711
bool IsRetriable(Message *request)
void SetHostList(HostList *hostList)
Set host list.
Definition: XrdClXRootDMsgHandler.hh:371
friend class HandleRspJob
Definition: XrdClXRootDMsgHandler.hh:112
uint16_t pNotAuthorizedCounter
Definition: XrdClXRootDMsgHandler.hh:706
ChunkList * pChunkList
Definition: XrdClXRootDMsgHandler.hh:702
std::unique_ptr< RedirectEntry > pRdirEntry
Definition: XrdClXRootDMsgHandler.hh:736
HostList * pHosts
Definition: XrdClXRootDMsgHandler.hh:697
static const size_t PageSize
Definition: XrdClXRootDMsgHandler.hh:645
uint32_t pAsyncOffset
Definition: XrdClXRootDMsgHandler.hh:708
bool OmitWait(Message *request, const URL &url)
std::atomic< bool > pTimeoutFence
Definition: XrdClXRootDMsgHandler.hh:746
void HandleResponse()
Unpack the message and call the response handler.
bool pReadVRawChunkHeaderDone
Definition: XrdClXRootDMsgHandler.hh:722
static const size_t MaxSslErrRetry
Definition: XrdClXRootDMsgHandler.hh:648
static const size_t CksumSize
Definition: XrdClXRootDMsgHandler.hh:646
uint32_t pReadRawCurrentOffset
Definition: XrdClXRootDMsgHandler.hh:716
XRootDStatus * ProcessStatus()
Extract the status information from the stuff that we got.
HostInfo pLoadBalancer
Definition: XrdClXRootDMsgHandler.hh:699
void UpdateTriedCGI(uint32_t errNo=0)
Update the "tried=" part of the CGI of the current message.
bool pOtherRawStarted
Definition: XrdClXRootDMsgHandler.hh:729
LocalFileHandler * pLFileHandler
Definition: XrdClXRootDMsgHandler.hh:691
void SetLoadBalancer(const HostInfo &loadBalancer)
Set the load balancer.
Definition: XrdClXRootDMsgHandler.hh:360
static Status ReadBytesAsync(Socket *socket, char *&buffer, uint32_t toBeRead, uint32_t &bytesRead)
Read a buffer asynchronously.
void HandleLocalRedirect(URL *url)
Handle a redirect to a local file.
Status RewriteRequestWait()
Some requests need to be rewritten also after getting kXR_wait - sigh.
bool RetriableErrorResponse(const Status &status)
Status ReadAsync(Socket *socket, uint32_t &bytesRead)
Definition: XrdClXRootDMsgHandler.hh:454
Status ReadRawRead(Message *msg, Socket *socket, uint32_t &bytesRead)
Handle a kXR_read in raw mode.
void DumpRedirectTraceBack()
Dump the redirect-trace-back into the log file.
virtual uint16_t GetSid() const
Status ParseResponse(AnyObject *&response)
virtual void OnStatusReady(const Message *message, XRootDStatus status)
The requested action has been performed and the status is available.
URL * pEffectiveDataServerUrl
Definition: XrdClXRootDMsgHandler.hh:688
std::vector< ChunkStatus > pChunkStatus
Definition: XrdClXRootDMsgHandler.hh:704
Status ReadPageAsync(Socket *socket, uint32_t &bytesRead)
bool pReadRawStarted
Definition: XrdClXRootDMsgHandler.hh:715
std::string pRedirectUrl
Definition: XrdClXRootDMsgHandler.hh:701
virtual uint16_t Examine(Message *msg)
XRootDMsgHandler(Message *msg, ResponseHandler *respHandler, const URL *url, std::shared_ptr< SIDManager > sidMgr, LocalFileHandler *lFileHandler)
Definition: XrdClXRootDMsgHandler.hh:125
bool pOksofarAsAnswer
Definition: XrdClXRootDMsgHandler.hh:696
uint32_t pReadVRawMsgOffset
Definition: XrdClXRootDMsgHandler.hh:721
RedirectTraceBack pRedirectTraceBack
Definition: XrdClXRootDMsgHandler.hh:737
bool pDirListWithStat
Definition: XrdClXRootDMsgHandler.hh:754
Status ReadRawPgRead(Message *msg, Socket *socket, uint32_t &bytesRead)
Handle a kXR_pgread in raw mode.
void SwitchOnRefreshFlag()
Switch on the refresh flag for some requests.
int32_t pReadVRawChunkIndex
Definition: XrdClXRootDMsgHandler.hh:725
std::vector< uint32_t > pPgReadCksums
Definition: XrdClXRootDMsgHandler.hh:719
Status ReadFromBuffer(char *&buffer, size_t &buflen, size_t size, std::string &result)
int pAggregatedWaitTime
Definition: XrdClXRootDMsgHandler.hh:734
std::shared_ptr< SIDManager > pSidMgr
Definition: XrdClXRootDMsgHandler.hh:690
~XRootDMsgHandler()
Destructor.
Definition: XrdClXRootDMsgHandler.hh:205
PostMaster * pPostMaster
Definition: XrdClXRootDMsgHandler.hh:689
void WaitDone(time_t now)
Status PostProcessReadV(VectorReadInfo *vReadInfo)
Post process vector read.
size_t pSslErrCnt
Definition: XrdClXRootDMsgHandler.hh:765
Status RewriteRequestRedirect(const URL &newUrl)
void SetStateful(bool stateful)
Definition: XrdClXRootDMsgHandler.hh:410
bool pStateful
Definition: XrdClXRootDMsgHandler.hh:733
bool pReadVRawMsgDiscard
Definition: XrdClXRootDMsgHandler.hh:727
bool pReadVRawSizeError
Definition: XrdClXRootDMsgHandler.hh:724
readahead_list pReadVRawChunkHeader
Definition: XrdClXRootDMsgHandler.hh:726
char * pAsyncReadBuffer
Definition: XrdClXRootDMsgHandler.hh:712
void Copy(uint32_t offchlst, char *buffer, size_t length)
Definition: XrdClXRootDMsgHandler.hh:657
virtual uint8_t OnStreamEvent(StreamEvent event, XRootDStatus status)
Status ReadPagesAsync(Socket *socket, uint32_t &bytesRead)
Definition: XrdClXRootDMsgHandler.hh:468
XrdSys::KernelBuffer * pKBuff
Definition: XrdClXRootDMsgHandler.hh:703
bool pFollowMetalink
Definition: XrdClXRootDMsgHandler.hh:731
void HandleError(XRootDStatus status, Message *msg=0)
Recover error.
time_t pExpiration
Definition: XrdClXRootDMsgHandler.hh:694
Status ReadRawOther(Message *msg, Socket *socket, uint32_t &bytesRead)
Handle anything other than kXR_read and kXR_readv in raw mode.
Status ReadRawReadV(Message *msg, Socket *socket, uint32_t &bytesRead)
Handle a kXR_readv in raw mode.
Status RetryAtServer(const URL &url, RedirectEntry::Type entryType)
Retry the request at another server.
uint16_t pRedirectCounter
Definition: XrdClXRootDMsgHandler.hh:705
Message * pRequest
Definition: XrdClXRootDMsgHandler.hh:683
static const size_t PageWithCksum
Definition: XrdClXRootDMsgHandler.hh:647
void SetOksofarAsAnswer(bool oksofarAsAnswer)
Definition: XrdClXRootDMsgHandler.hh:344
virtual XRootDStatus ReadMessageBody(Message *msg, Socket *socket, uint32_t &bytesRead)
void SetKernelBuffer(XrdSys::KernelBuffer *kbuff)
Set the kernel buffer.
Definition: XrdClXRootDMsgHandler.hh:392
bool pHasSessionId
Definition: XrdClXRootDMsgHandler.hh:700
uint32_t pAsyncMsgSize
Definition: XrdClXRootDMsgHandler.hh:713
virtual bool IsRaw() const
Are we a raw writer or not?
virtual void Process(Message *msg)
URL pUrl
Definition: XrdClXRootDMsgHandler.hh:687
uint32_t pAsyncChunkOffset
Definition: XrdClXRootDMsgHandler.hh:709
static size_t NbPages(uint32_t dlen)
Definition: XrdClXRootDMsgHandler.hh:650
Status ParseXAttrResponse(char *data, size_t len, AnyObject *&response)
XrdSysCondVar pCV
Definition: XrdClXRootDMsgHandler.hh:760
ResponseHandler * pResponseHandler
Definition: XrdClXRootDMsgHandler.hh:686
Status pLastError
Definition: XrdClXRootDMsgHandler.hh:693
std::vector< Message * > pPartialResps
Definition: XrdClXRootDMsgHandler.hh:685
bool pReadVRawChunkHeaderStarted
Definition: XrdClXRootDMsgHandler.hh:723
XRootDStatus pStatus
Definition: XrdClXRootDMsgHandler.hh:692
std::list< std::unique_ptr< RedirectEntry > > RedirectTraceBack
Definition: XrdClXRootDMsgHandler.hh:643
void SetExpiration(time_t expiration)
Set a timestamp after which we give up.
Definition: XrdClXRootDMsgHandler.hh:326
virtual uint16_t InspectStatusRsp(Message *msg)
bool pRedirectAsAnswer
Definition: XrdClXRootDMsgHandler.hh:695
Message * pResponse
Definition: XrdClXRootDMsgHandler.hh:684
void SetRedirectAsAnswer(bool redirectAsAnswer)
Definition: XrdClXRootDMsgHandler.hh:335
uint32_t pAsyncChunkIndex
Definition: XrdClXRootDMsgHandler.hh:710
Status ReadFromBuffer(char *&buffer, size_t &buflen, T &result)
void TakeDownTimeoutFence()
Take down the timeout fence after oksofar response has been handled.
Request status.
Definition: XrdClXRootDResponses.hh:219
Definition: XrdSysPthread.hh:79
Definition: XrdSysKernelBuffer.hh:46
Definition: XrdClAnyObject.hh:26
const uint16_t suRetry
Definition: XrdClStatus.hh:40
std::vector< HostInfo > HostList
Definition: XrdClXRootDResponses.hh:1045
const uint64_t ExDbgMsg
Definition: XrdClConstants.hh:44
std::vector< ChunkInfo > ChunkList
List of chunks.
Definition: XrdClXRootDResponses.hh:980
static const int PageSize
Definition: XrdSysPageSize.hh:36
Definition: XProtocol.hh:500
kXR_int32 rlen
Definition: XProtocol.hh:505
Definition: XProtocol.hh:154
kXR_unt16 requestid
Definition: XProtocol.hh:156
Definition: XrdClXRootDResponses.hh:1034
URL url
URL of the host.
Definition: XrdClXRootDResponses.hh:1042
Definition: XrdClXRootDMsgHandler.hh:61
Type type
Definition: XrdClXRootDMsgHandler.hh:78
RedirectEntry(const URL &from, const URL &to, Type type)
Definition: XrdClXRootDMsgHandler.hh:70
XRootDStatus status
Definition: XrdClXRootDMsgHandler.hh:79
URL from
Definition: XrdClXRootDMsgHandler.hh:76
std::string ToString(bool prevok=true)
Definition: XrdClXRootDMsgHandler.hh:81
URL to
Definition: XrdClXRootDMsgHandler.hh:77
Type
Definition: XrdClXRootDMsgHandler.hh:63
@ EntryRedirect
Definition: XrdClXRootDMsgHandler.hh:64
@ EntryRetry
Definition: XrdClXRootDMsgHandler.hh:66
@ EntryRedirectOnWait
Definition: XrdClXRootDMsgHandler.hh:65
@ EntryWait
Definition: XrdClXRootDMsgHandler.hh:67
Procedure execution status.
Definition: XrdClStatus.hh:113
uint16_t code
Error type, or additional hints on what to do.
Definition: XrdClStatus.hh:145
bool IsOK() const
We're fine.
Definition: XrdClStatus.hh:122
Definition: XrdClXRootDMsgHandler.hh:637
ChunkStatus()
Definition: XrdClXRootDMsgHandler.hh:638
bool sizeError
Definition: XrdClXRootDMsgHandler.hh:639
bool done
Definition: XrdClXRootDMsgHandler.hh:640
Definition: XProtocol.hh:651