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 "XrdCl/XrdClLocalFileHandler.hh"
#include "XrdCl/XrdClOptional.hh"
#include "XrdCl/XrdClPlugInInterface.hh"
#include "XrdSys/XrdSysPthread.hh"
#include "XrdSys/XrdSysPageSize.hh"
 
#include <list>
#include <set>
#include <vector>
 
#include <sys/time.h>
#include <sys/uio.h>
#include <cstdint>
 
namespace
{
  class PgReadHandler;
  class PgReadRetryHandler;
  class PgReadSubstitutionHandler;
  class OpenHandler;
}
 
namespace XrdCl
{
  class Message;
  class EcHandler;
  class FileStateHandler;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  struct PgReadFlags
  {
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum Flags
      {
        None  = 0,                      //< Nothing
        Retry = XrdProto::kXR_pgRetry  //< Retry reading currupted page
 
      };
  };
  XRDOUC_ENUM_OPERATORS( PgReadFlags::Flags )
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class FileStateHandlerTemplate : public ExportedFileTemplate
  {
   public:
      FileStateHandlerTemplate(std::shared_ptr<FileStateHandler> fhp) :
          pTemplateFileWp(fhp) { }
 
      ~FileStateHandlerTemplate() { }
 
      std::weak_ptr<FileStateHandler> pTemplateFileWp;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class FileStateHandler
  {
      friend class ::PgReadHandler;
      friend class ::PgReadRetryHandler;
      friend class ::PgReadSubstitutionHandler;
      friend class ::OpenHandler;
 
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum FileStatus
      {
        Closed,           
        Opened,           
        Error,            
        Recovering,       
        OpenInProgress,   
        CloseInProgress   
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FileStateHandler( FilePlugIn *& plugin );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FileStateHandler( bool useVirtRedirector, FilePlugIn *& plugin );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ~FileStateHandler();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus Open( std::shared_ptr<FileStateHandler> &self,
                                const std::string                 &url,
                                OpenFlags::Flags                   flags,
                                uint16_t                           mode,
                                ResponseHandler                   *handler,
                                time_t                             timeout  = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus OpenUsingTemplate(
                              std::shared_ptr<FileStateHandler> &self,
                              ExportedFileTemplate              *templ,
                              const std::string                 &url,
                              OpenFlags::Flags                   flags,
                              uint16_t                           mode,
                              ResponseHandler                   *handler,
                              time_t                             timeout  = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus Close( std::shared_ptr<FileStateHandler> &self,
                                 ResponseHandler                   *handler,
                                 time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus Stat( std::shared_ptr<FileStateHandler> &self,
                                bool                               force,
                                ResponseHandler                   *handler,
                                time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus PreRead( std::shared_ptr<FileStateHandler> &self,
                                   const TractList                   &tracts,
                                   ResponseHandler                   *handler,
                                   time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus Read( std::shared_ptr<FileStateHandler> &self,
                                uint64_t                           offset,
                                uint32_t                           size,
                                void                              *buffer,
                                ResponseHandler                   *handler,
                                time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus PgRead( std::shared_ptr<FileStateHandler> &self,
                                  uint64_t                           offset,
                                  uint32_t                           size,
                                  void                              *buffer,
                                  ResponseHandler                   *handler,
                                  time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus PgReadRetry( std::shared_ptr<FileStateHandler> &self,
                                       uint64_t                           offset,
                                       uint32_t                           size,
                                       size_t                             pgnb,
                                       void                              *buffer,
                                       PgReadHandler                     *handler,
                                       time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus PgReadImpl( std::shared_ptr<FileStateHandler> &self,
                                      uint64_t                           offset,
                                      uint32_t                           size,
                                      void                              *buffer,
                                      uint16_t                           flags,
                                      ResponseHandler                   *handler,
                                      time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus Write( std::shared_ptr<FileStateHandler> &self,
                                 uint64_t                           offset,
                                 uint32_t                           size,
                                 const void                        *buffer,
                                 ResponseHandler                   *handler,
                                 time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus Write( std::shared_ptr<FileStateHandler> &self,
                                 uint64_t                           offset,
                                 Buffer                           &&buffer,
                                 ResponseHandler                   *handler,
                                 time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus Write( std::shared_ptr<FileStateHandler> &self,
                                 uint64_t                           offset,
                                 uint32_t                           size,
                                 Optional<uint64_t>                 fdoff,
                                 int                                fd,
                                 ResponseHandler                   *handler,
                                 time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus PgWrite( std::shared_ptr<FileStateHandler> &self,
                                   uint64_t                           offset,
                                   uint32_t                           size,
                                   const void                        *buffer,
                                   std::vector<uint32_t>             &cksums,
                                   ResponseHandler                   *handler,
                                   time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus PgWriteRetry( std::shared_ptr<FileStateHandler> &self,
                                        uint64_t                           offset,
                                        uint32_t                           size,
                                        const void                        *buffer,
                                        uint32_t                           digest,
                                        ResponseHandler                   *handler,
                                        time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus PgWriteImpl( std::shared_ptr<FileStateHandler> &self,
                                       uint64_t                           offset,
                                       uint32_t                           size,
                                       const void                        *buffer,
                                       std::vector<uint32_t>             &cksums,
                                       kXR_char                           flags,
                                       ResponseHandler                   *handler,
                                       time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus Sync( std::shared_ptr<FileStateHandler> &self,
                                ResponseHandler                   *handler,
                                time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus Truncate( std::shared_ptr<FileStateHandler> &self,
                                    uint64_t                           size,
                                    ResponseHandler                   *handler,
                                    time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus VectorRead( std::shared_ptr<FileStateHandler> &self,
                                      const ChunkList                   &chunks,
                                      void                              *buffer,
                                      ResponseHandler                   *handler,
                                      time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus VectorWrite( std::shared_ptr<FileStateHandler> &self,
                                       const ChunkList                   &chunks,
                                       ResponseHandler                   *handler,
                                       time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus WriteV( std::shared_ptr<FileStateHandler> &self,
                                  uint64_t                           offset,
                                  const struct iovec                *iov,
                                  int                                iovcnt,
                                  ResponseHandler                   *handler,
                                  time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus ReadV( std::shared_ptr<FileStateHandler> &self,
                                 uint64_t                           offset,
                                 struct iovec                      *iov,
                                 int                                iovcnt,
                                 ResponseHandler                   *handler,
                                 time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus Fcntl( std::shared_ptr<FileStateHandler> &self,
                                 QueryCode::Code                    queryCode,
                                 const Buffer                      &arg,
                                 ResponseHandler                   *handler,
                                 time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus Visa( std::shared_ptr<FileStateHandler> &self,
                                ResponseHandler                   *handler,
                                time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus SetXAttr( std::shared_ptr<FileStateHandler> &self,
                                    const std::vector<xattr_t>        &attrs,
                                    ResponseHandler                   *handler,
                                    time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus GetXAttr( std::shared_ptr<FileStateHandler> &self,
                                    const std::vector<std::string>    &attrs,
                                    ResponseHandler                   *handler,
                                    time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus DelXAttr( std::shared_ptr<FileStateHandler> &self,
                                    const std::vector<std::string>    &attrs,
                                    ResponseHandler                   *handler,
                                    time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus ListXAttr( std::shared_ptr<FileStateHandler> &self,
                                     ResponseHandler                  *handler,
                                     time_t                            timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus Checkpoint( std::shared_ptr<FileStateHandler> &self,
                                      kXR_char                           code,
                                      ResponseHandler                   *handler,
                                      time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus ChkptWrt( std::shared_ptr<FileStateHandler> &self,
                                    uint64_t                           offset,
                                    uint32_t                           size,
                                    const void                        *buffer,
                                    ResponseHandler                   *handler,
                                    time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus ChkptWrtV( std::shared_ptr<FileStateHandler> &self,
                                     uint64_t                           offset,
                                     const struct iovec                *iov,
                                     int                                iovcnt,
                                     ResponseHandler                   *handler,
                                     time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus Clone(std::shared_ptr<FileStateHandler>      &self,
                                const CloneLocations                   &locs,
                                ResponseHandler                        *handler,
                                time_t                                  timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void OnOpen( const XRootDStatus *status,
                   const OpenInfo     *openInfo,
                   const HostList     *hostList );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void OnClose( const XRootDStatus *status );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static void OnStateError( std::shared_ptr<FileStateHandler> &self,
                                XRootDStatus                      *status,
                                Message                           *message,
                                ResponseHandler                   *userHandler,
                                MessageSendParams                 &sendParams );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static void OnStateRedirection( std::shared_ptr<FileStateHandler> &self,
                                      const std::string                 &redirectUrl,
                                      Message                           *message,
                                      ResponseHandler                   *userHandler,
                                      MessageSendParams                 &sendParams );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static void OnStateResponse( std::shared_ptr<FileStateHandler> &self,
                                   XRootDStatus                      *status,
                                   Message                           *message,
                                   AnyObject                         *response,
                                   HostList                          *hostList );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool IsOpen() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline bool IsSecure() const
      {
        return pIsChannelEncrypted;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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();
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus TryOtherServer( std::shared_ptr<FileStateHandler> &self,
                                          time_t                             timeout );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static std::unique_ptr<ExportedFileTemplate> ExportTemplate(
                                 std::shared_ptr<FileStateHandler> &self )
      {
        return std::make_unique<FileStateHandlerTemplate>(self);
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool NeedFileTempl() const
      {
        if( (pOpenFlags & OpenFlags::Dup) || (pOpenFlags & OpenFlags::Samefs) )
          return true;
        return false;
      }
 
    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;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<typename T>
      static Status XAttrOperationImpl( std::shared_ptr<FileStateHandler> &self,
                                        kXR_char                           subcode,
                                        kXR_char                           options,
                                        const std::vector<T>              &attrs,
                                        ResponseHandler                   *handler,
                                        time_t                             timeout = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static Status SendOrQueue( std::shared_ptr<FileStateHandler> &self,
                                 const URL                         &url,
                                 Message                           *msg,
                                 ResponseHandler                   *handler,
                                 MessageSendParams                 &sendParams );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool IsRecoverable( const XRootDStatus &stataus ) const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static Status RecoverMessage( std::shared_ptr<FileStateHandler> &self,
                                    RequestData                        rd,
                                    bool callbackOnFailure = true );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static Status RunRecovery( std::shared_ptr<FileStateHandler> &self );
 
      //------------------------------------------------------------------------
      // Send a close and ignore the response
      //------------------------------------------------------------------------
      static XRootDStatus SendClose( std::shared_ptr<FileStateHandler> &self,
                                     time_t                             timeout );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool IsReadOnly() const;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus ReOpenFileAtServer( std::shared_ptr<FileStateHandler> &self,
                                              const URL                         &url,
                                              time_t                             timeout );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void FailMessage( RequestData rd, XRootDStatus status );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void FailQueuedMessages( XRootDStatus status );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus FillFhTempl( std::shared_ptr<FileStateHandler> &self,
                                       const URL                         &url,
                                       Message                           *msg,
                                       URL                               &sendUrl );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus OpenImpl( std::shared_ptr<FileStateHandler> &self,
                                const std::string                 &url,
                                OpenFlags::Flags                   flags,
                                uint16_t                           mode,
                                ResponseHandler                   *handler,
                                time_t                             timeout  = 0 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      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 );
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus WriteKernelBuffer( std::shared_ptr<FileStateHandler>     &self,
                                             uint64_t                               offset,
                                             uint32_t                               length,
                                             std::unique_ptr<XrdSys::KernelBuffer>  kbuff,
                                             ResponseHandler                       *handler,
                                             time_t                                 timeout );
 
      mutable XrdSysMutex     pMutex;
      FileStatus              pFileState;
      XRootDStatus            pStatus;
      StatInfo               *pStatInfo;
      URL                    *pFileUrl;
      URL                    *pDataServer;
      URL                    *pLoadBalancer;
      URL                    *pStateRedirect;
      URL                    *pWrtRecoveryRedir;
      uint8_t                *pFileHandle;
      uint16_t                pOpenMode;
      OpenFlags::Flags        pOpenFlags;
      RequestList             pToBeRecovered;
      std::set<Message*>      pInTheFly;
      uint64_t                pSessionId;
      bool                    pDoRecoverRead;
      bool                    pDoRecoverWrite;
      bool                    pFollowRedirects;
      bool                    pUseVirtRedirector;
      bool                    pIsChannelEncrypted;
      bool                    pAllowBundledClose;
 
      //------------------------------------------------------------------------
      // 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;
 
      //------------------------------------------------------------------------
      // Responsible for file:// operations on the local filesystem
      //------------------------------------------------------------------------
      LocalFileHandler      *pLFileHandler;
 
      //------------------------------------------------------------------------
      // Responsible for Writing/Reading erasure-coded files
      //------------------------------------------------------------------------
      FilePlugIn           *&pPlugin;
 
      //------------------------------------------------------------------------
      // Used to select use of file template, with optional duplication on open
      //------------------------------------------------------------------------
      std::weak_ptr<FileStateHandler> pTemplateFileWp;
  };
}
 
#endif // __XRD_CL_FILE_STATE_HANDLER_HH__