XrdClFileStateHandler.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// Copyright (c) 2011-2014 by European Organization for Nuclear Research (CERN)
// Author: Lukasz Janyst <ljanyst@cern.ch>
//------------------------------------------------------------------------------
// This file is part of the XRootD software suite.
//
// XRootD is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// XRootD is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with XRootD.  If not, see <http://www.gnu.org/licenses/>.
//
// In applying this licence, CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
//------------------------------------------------------------------------------
 
#ifndef __XRD_CL_FILE_STATE_HANDLER_HH__
#define __XRD_CL_FILE_STATE_HANDLER_HH__
 
#include "XrdCl/XrdClXRootDResponses.hh"
#include "XrdCl/XrdClPostMasterInterfaces.hh"
#include "XrdCl/XrdClFileSystem.hh"
#include "XrdCl/XrdClMessageUtils.hh"
#include "XrdSys/XrdSysPthread.hh"
#include "XrdCl/XrdClLocalFileHandler.hh"
#include <list>
#include <set>
 
#include <sys/uio.h>
 
namespace XrdCl
{
  class ResponseHandlerHolder;
  class Message;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class FileStateHandler
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum FileStatus
      {
        Closed,           
        Opened,           
        Error,            
        Recovering,       
        OpenInProgress,   
        CloseInProgress   
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FileStateHandler();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FileStateHandler( bool useVirtRedirector );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ~FileStateHandler();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Open( const std::string &url,
                         uint16_t           flags,
                         uint16_t           mode,
                         ResponseHandler   *handler,
                         uint16_t           timeout  = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Close( ResponseHandler *handler,
                          uint16_t         timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Stat( bool             force,
                         ResponseHandler *handler,
                         uint16_t         timeout = 0 );
 
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Read( uint64_t         offset,
                         uint32_t         size,
                         void            *buffer,
                         ResponseHandler *handler,
                         uint16_t         timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Write( uint64_t         offset,
                          uint32_t         size,
                          const void      *buffer,
                          ResponseHandler *handler,
                          uint16_t         timeout = 0 );
 
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Sync( ResponseHandler *handler,
                         uint16_t         timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Truncate( uint64_t         size,
                             ResponseHandler *handler,
                             uint16_t         timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus VectorRead( const ChunkList &chunks,
                               void            *buffer,
                               ResponseHandler *handler,
                               uint16_t         timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus VectorWrite( const ChunkList &chunks,
                                ResponseHandler *handler,
                                uint16_t         timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus WriteV( uint64_t            offset,
                                const struct iovec *iov,
                                int                 iovcnt,
                                ResponseHandler    *handler,
                                uint16_t            timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Fcntl( const Buffer    &arg,
                          ResponseHandler *handler,
                          uint16_t         timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus Visa( ResponseHandler *handler,
                         uint16_t         timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void OnOpen( const XRootDStatus *status,
                   const OpenInfo     *openInfo,
                   const HostList     *hostList );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void OnClose( const XRootDStatus *status );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void OnStateError( XRootDStatus        *status,
                         Message             *message,
                         ResponseHandler     *userHandler,
                         MessageSendParams   &sendParams );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void OnStateRedirection( const std::string &redirectUrl,
                               Message           *message,
                               ResponseHandler   *userHandler,
                               MessageSendParams &sendParams );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void OnStateResponse( XRootDStatus *status,
                            Message      *message,
                            AnyObject    *response,
                            HostList     *hostList );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool IsOpen() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool SetProperty( const std::string &name, const std::string &value );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool GetProperty( const std::string &name, std::string &value ) const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void Lock()
      {
        pMutex.Lock();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void UnLock()
      {
        pMutex.UnLock();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void Tick( time_t now );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void TimeOutRequests( time_t now );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void AfterForkChild();
 
    private:
      //------------------------------------------------------------------------
      // Helper for queuing messages
      //------------------------------------------------------------------------
      struct RequestData
      {
        RequestData(): request(0), handler(0) {}
        RequestData( Message *r, ResponseHandler *h,
                     const MessageSendParams &p ):
          request(r), handler(h), params(p) {}
        Message           *request;
        ResponseHandler   *handler;
        MessageSendParams  params;
      };
      typedef std::list<RequestData> RequestList;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Status SendOrQueue( const URL         &url,
                          Message           *msg,
                          ResponseHandler   *handler,
                          MessageSendParams &sendParams );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool IsRecoverable( const XRootDStatus &stataus ) const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Status RecoverMessage( RequestData rd, bool callbackOnFailure = true );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Status RunRecovery();
 
      //------------------------------------------------------------------------
      // Send a close and ignore the response
      //------------------------------------------------------------------------
      Status SendClose( uint16_t timeout );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool IsReadOnly() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Status ReOpenFileAtServer( const URL &url, uint16_t timeout );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void FailMessage( RequestData rd, XRootDStatus status );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void FailQueuedMessages( XRootDStatus status );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void ReSendQueuedMessages();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void ReWriteFileHandle( Message *msg );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void ResetMonitoringVars()
      {
        pOpenTime.tv_sec = 0; pOpenTime.tv_usec = 0;
        pRBytes      = 0;
        pVRBytes     = 0;
        pWBytes      = 0;
        pVSegs       = 0;
        pRCount      = 0;
        pVRCount     = 0;
        pWCount      = 0;
        pCloseReason = Status();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void MonitorClose( const XRootDStatus *status );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus IssueRequest( const URL         &url,
                                 Message           *msg,
                                 ResponseHandler   *handler,
                                 MessageSendParams &sendParams );
 
      mutable XrdSysMutex     pMutex;
      FileStatus              pFileState;
      XRootDStatus            pStatus;
      StatInfo               *pStatInfo;
      URL                    *pFileUrl;
      URL                    *pDataServer;
      URL                    *pLoadBalancer;
      URL                    *pStateRedirect;
      uint8_t                *pFileHandle;
      uint16_t                pOpenMode;
      uint16_t                pOpenFlags;
      RequestList             pToBeRecovered;
      std::set<Message*>      pInTheFly;
      uint64_t                pSessionId;
      bool                    pDoRecoverRead;
      bool                    pDoRecoverWrite;
      bool                    pFollowRedirects;
      bool                    pUseVirtRedirector;
 
      //------------------------------------------------------------------------
      // Monitoring variables
      //------------------------------------------------------------------------
      timeval                  pOpenTime;
      uint64_t                 pRBytes;
      uint64_t                 pVRBytes;
      uint64_t                 pWBytes;
      uint64_t                 pVWBytes;
      uint64_t                 pVSegs;
      uint64_t                 pRCount;
      uint64_t                 pVRCount;
      uint64_t                 pWCount;
      uint64_t                 pVWCount;
      XRootDStatus             pCloseReason;
 
      //------------------------------------------------------------------------
      // Holds the OpenHanlder used to issue reopen
      // (there is only only OpenHandler reopening a file at a time)
      //------------------------------------------------------------------------
      ResponseHandlerHolder *pReOpenHandler;
 
      //------------------------------------------------------------------------
      // Responsible for file:// operations on the local filesystem
      //------------------------------------------------------------------------
      LocalFileHandler      *pLFileHandler;
  };
}
 
#endif // __XRD_CL_FILE_STATE_HANDLER_HH__