XrdClFileOperations.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// Copyright (c) 2011-2017 by European Organization for Nuclear Research (CERN)
// Author: Krzysztof Jamrog <krzysztof.piotr.jamrog@cern.ch>,
//         Michal Simon <michal.simon@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_OPERATIONS_HH__
#define __XRD_CL_FILE_OPERATIONS_HH__
 
#include "XrdCl/XrdClFile.hh"
#include "XrdCl/XrdClOperations.hh"
#include "XrdCl/XrdClOperationHandlers.hh"
 
namespace XrdCl
{
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<template<bool> class Derived, bool HasHndl, typename Response, typename ... Arguments>
  class FileOperation: public ConcreteOperation<Derived, HasHndl, Response, Arguments...>
  {
 
      template<template<bool> class, bool, typename, typename ...> friend class FileOperation;
 
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FileOperation( File *f, Arguments... args): ConcreteOperation<Derived, false, Response, Arguments...>( std::move( args )... ), file(f)
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FileOperation( File &f, Arguments... args): FileOperation( &f, std::move( args )... )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<bool from>
      FileOperation( FileOperation<Derived, from, Response, Arguments...> && op ) :
        ConcreteOperation<Derived, HasHndl, Response, Arguments...>( std::move( op ) ), file( op.file )
      {
 
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~FileOperation()
      {
 
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      File *file;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class OpenImpl: public FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>,
      Arg<OpenFlags::Flags>, Arg<Access::Mode>>
  {
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      struct ExResp : public Resp<void>
      {
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          ExResp( XrdCl::File &file ): file( file )
          {
          }
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          inline ResponseHandler* Create( std::function<void( XRootDStatus&,
              StatInfo& )> func )
          {
            return new ExOpenFuncWrapper( this->file, func );
          }
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          using Resp<void>::Create;
 
          //--------------------------------------------------------------------
          //--------------------------------------------------------------------
          XrdCl::File &file;
      };
 
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      OpenImpl( File *f, Arg<std::string> url, Arg<OpenFlags::Flags> flags,
                Arg<Access::Mode> mode = Access::None ) :
          FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>, Arg<OpenFlags::Flags>,
            Arg<Access::Mode>>( f, std::move( url ), std::move( flags ), std::move( mode ) )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      OpenImpl( File &f, Arg<std::string> url, Arg<OpenFlags::Flags> flags,
                Arg<Access::Mode> mode = Access::None ) :
          FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>, Arg<OpenFlags::Flags>,
            Arg<Access::Mode>>( &f, std::move( url ), std::move( flags ), std::move( mode ) )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<bool from>
      OpenImpl( OpenImpl<from> && open ) :
          FileOperation<OpenImpl, HasHndl, Resp<void>, Arg<std::string>,
              Arg<OpenFlags::Flags>, Arg<Access::Mode>>( std::move( open ) )
      {
      }
 
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { UrlArg, FlagsArg, ModeArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<typename Hdlr>
      OpenImpl<true> operator>>( Hdlr &&hdlr )
      {
        // check if the resulting handler should be owned by us or by the user,
        // if the user passed us directly a ResponseHandler it's owned by the
        // user, otherwise we need to wrap the argument in a handler and in this
        // case the resulting handler will be owned by us
        constexpr bool own = !IsResponseHandler<Hdlr>::value;
        ExResp factory( *this->file );
        return this->StreamImpl( factory.Create( hdlr ), own );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Open";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl()
      {
        try
        {
          std::string      url   = std::get<UrlArg>( this->args ).Get();
          OpenFlags::Flags flags = std::get<FlagsArg>( this->args ).Get();
          Access::Mode     mode  = std::get<ModeArg>( this->args ).Get();
          return this->file->Open( url, flags, mode, this->handler.get() );
        }
        catch( const PipelineException& ex )
        {
          return ex.GetError();
        }
        catch( const std::exception& ex )
        {
          return XRootDStatus( stError, ex.what() );
        }
      }
  };
  typedef OpenImpl<false> Open;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class ReadImpl: public FileOperation<ReadImpl, HasHndl, Resp<ChunkInfo>,
      Arg<uint64_t>, Arg<uint32_t>, Arg<void*>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<ReadImpl, HasHndl, Resp<ChunkInfo>, Arg<uint64_t>,
                          Arg<uint32_t>, Arg<void*>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { OffsetArg, SizeArg, BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Read";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl()
      {
        try
        {
          uint64_t  offset = std::get<OffsetArg>( this->args ).Get();
          uint32_t  size   = std::get<SizeArg>( this->args ).Get();
          void     *buffer = std::get<BufferArg>( this->args ).Get();
          return this->file->Read( offset, size, buffer, this->handler.get() );
        }
        catch( const PipelineException& ex )
        {
          return ex.GetError();
        }
        catch( const std::exception& ex )
        {
          return XRootDStatus( stError, ex.what() );
        }
      }
  };
  typedef ReadImpl<false> Read;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class CloseImpl: public FileOperation<CloseImpl, HasHndl, Resp<void>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<CloseImpl, HasHndl, Resp<void>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Close";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl()
      {
        return this->file->Close( this->handler.get() );
      }
  };
  typedef CloseImpl<false> Close;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class StatImpl: public FileOperation<StatImpl, HasHndl, Resp<StatInfo>, Arg<bool>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<StatImpl, HasHndl, Resp<StatInfo>, Arg<bool>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { ForceArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Stat";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl()
      {
        try
        {
          bool force = std::get<ForceArg>( this->args ).Get();
          return this->file->Stat( force, this->handler.get() );
        }
        catch( const PipelineException& ex )
        {
          return ex.GetError();
        }
        catch( const std::exception& ex )
        {
          return XRootDStatus( stError, ex.what() );
        }
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  StatImpl<false> Stat( File *file, Arg<bool> force )
  {
    return StatImpl<false>( file, std::move( force ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  StatImpl<false> Stat( File &file, Arg<bool> force )
  {
    return StatImpl<false>( file, std::move( force ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class WriteImpl: public FileOperation<WriteImpl, HasHndl, Resp<void>, Arg<uint64_t>,
      Arg<uint32_t>, Arg<void*>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<WriteImpl, HasHndl, Resp<void>, Arg<uint64_t>, Arg<uint32_t>,
                          Arg<void*>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { OffsetArg, SizeArg, BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Write";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl()
      {
        try
        {
          uint64_t  offset = std::get<OffsetArg>( this->args ).Get();
          uint32_t  size   = std::get<SizeArg>( this->args ).Get();
          void     *buffer = std::get<BufferArg>( this->args ).Get();
          return this->file->Write( offset, size, buffer, this->handler.get() );
        }
        catch( const PipelineException& ex )
        {
          return ex.GetError();
        }
        catch( const std::exception& ex )
        {
          return XRootDStatus( stError, ex.what() );
        }
      }
  };
  typedef WriteImpl<false> Write;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class SyncImpl: public FileOperation<SyncImpl, HasHndl, Resp<void>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<SyncImpl, HasHndl, Resp<void>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Sync";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl()
      {
        return this->file->Sync( this->handler.get() );
      }
  };
  typedef SyncImpl<false> Sync;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class TruncateImpl: public FileOperation<TruncateImpl, HasHndl, Resp<void>, Arg<uint64_t>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<TruncateImpl, HasHndl, Resp<void>, Arg<uint64_t>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { SizeArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Truncate";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl()
      {
        try
        {
          uint64_t size = std::get<SizeArg>( this->args ).Get();
          return this->file->Truncate( size, this->handler.get() );
        }
        catch( const PipelineException& ex )
        {
          return ex.GetError();
        }
        catch( const std::exception& ex )
        {
          return XRootDStatus( stError, ex.what() );
        }
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  TruncateImpl<false> Truncate( File *file, Arg<uint64_t> size )
  {
    return TruncateImpl<false>( file, std::move( size ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  TruncateImpl<false> Truncate( File &file, Arg<uint64_t> size )
  {
    return TruncateImpl<false>( file, std::move( size ) );
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class VectorReadImpl: public FileOperation<VectorReadImpl, HasHndl,
      Resp<VectorReadInfo>, Arg<ChunkList>, Arg<void*>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<VectorReadImpl, HasHndl, Resp<VectorReadInfo>, Arg<ChunkList>,
                          Arg<void*>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { ChunksArg, BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "VectorRead";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl()
      {
        try
        {
          ChunkList chunks( std::get<ChunksArg>( this->args ).Get() );
          void *buffer = std::get<BufferArg>( this->args ).Get();
          return this->file->VectorRead( chunks, buffer, this->handler.get() );
        }
        catch( const PipelineException& ex )
        {
          return ex.GetError();
        }
        catch( const std::exception& ex )
        {
          return XRootDStatus( stError, ex.what() );
        }
      }
  };
  typedef VectorReadImpl<false> VectorRead;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class VectorWriteImpl: public FileOperation<VectorWriteImpl, HasHndl, Resp<void>,
      Arg<ChunkList>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<VectorWriteImpl, HasHndl, Resp<void>, Arg<ChunkList>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { ChunksArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "VectorWrite";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl()
      {
        try
        {
          const ChunkList chunks( std::get<ChunksArg>( this->args ).Get() );
          return this->file->VectorWrite( chunks, this->handler.get() );
        }
        catch( const PipelineException& ex )
        {
          return ex.GetError();
        }
        catch( const std::exception& ex )
        {
          return XRootDStatus( stError, ex.what() );
        }
      }
  };
  typedef VectorWriteImpl<false> VectorWrite;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class WriteVImpl: public FileOperation<WriteVImpl, HasHndl, Resp<void>, Arg<uint64_t>,
      Arg<struct iovec*>, Arg<int>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<WriteVImpl, HasHndl, Resp<void>, Arg<uint64_t>,
                          Arg<struct iovec*>, Arg<int>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { OffsetArg, IovArg, IovcntArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "WriteV";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl()
      {
        try
        {
          uint64_t            offset = std::get<OffsetArg>( this->args ).Get();
          const struct iovec *iov    = std::get<IovArg>( this->args ).Get();
          int                 iovcnt = std::get<IovcntArg>( this->args ).Get();
          return this->file->WriteV( offset, iov, iovcnt, this->handler.get() );
        }
        catch( const PipelineException& ex )
        {
          return ex.GetError();
        }
        catch( const std::exception& ex )
        {
          return XRootDStatus( stError, ex.what() );
        }
      }
  };
  typedef WriteVImpl<false> WriteV;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class FcntlImpl: public FileOperation<FcntlImpl, HasHndl, Resp<Buffer>, Arg<Buffer>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<FcntlImpl, HasHndl, Resp<Buffer>, Arg<Buffer>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum { BufferArg };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Fcntl";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl()
      {
        try
        {
          Buffer arg( std::get<BufferArg>( this->args ).Get() );
          return this->file->Fcntl( arg, this->handler.get() );
        }
        catch( const PipelineException& ex )
        {
          return ex.GetError();
        }
        catch( const std::exception& ex )
        {
          return XRootDStatus( stError, ex.what() );
        }
      }
  };
  typedef FcntlImpl<false> Fcntl;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<bool HasHndl>
  class VisaImpl: public FileOperation<VisaImpl, HasHndl, Resp<Buffer>>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using FileOperation<VisaImpl, HasHndl, Resp<Buffer>>::FileOperation;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string ToString()
      {
        return "Visa";
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus RunImpl()
      {
        return this->file->Visa( this->handler.get() );
      }
  };
  typedef VisaImpl<false> Visa;
}
 
#endif // __XRD_CL_FILE_OPERATIONS_HH__