XrdClOperationHandlers.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_OPERATION_HANDLERS_HH__
#define __XRD_CL_OPERATION_HANDLERS_HH__
 
#include "XrdCl/XrdClFile.hh"
#include "XrdCl/XrdClCtx.hh"
 
#include<functional>
#include<future>
#include <memory>
 
namespace XrdCl
{
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class UnpackXAttrStatus : public ResponseHandler
  {
    public:
 
      UnpackXAttrStatus( ResponseHandler *handler ) : handler( handler )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponse( XRootDStatus *status, AnyObject *response )
      {
        // status maybe error for old servers not supporting xattrs
        if( !status->IsOK() )
        {
          handler->HandleResponse( status, nullptr );
          return;
        }
 
        std::vector<XAttrStatus> *bulk = nullptr;
        response->Get( bulk );
        if (status && bulk && !bulk->empty()) {
          *status = bulk->front().status;
        }
        handler->HandleResponse( status, nullptr );
        delete response;
      }
 
    private:
 
      ResponseHandler *handler;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class UnpackXAttr : public ResponseHandler
  {
    public:
 
      UnpackXAttr( ResponseHandler *handler ) : handler( handler )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponse( XRootDStatus *status, AnyObject *response )
      {
        // status is always OK for bulk response
 
        std::vector<XAttr> *bulk = nullptr;
        response->Get( bulk );
 
        if (bulk && !bulk->empty()) {
          if (status)
            *status = bulk->front().status;
 
          std::string *rsp = new std::string(std::move(bulk->front().value));
          response->Set( rsp );
        }
 
        delete bulk;
        handler->HandleResponse( status, response );
      }
 
    private:
 
      ResponseHandler *handler;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Response>
  inline Response* GetResponse( AnyObject *rsp )
  {
    Response *ret = nullptr;
    rsp->Get( ret );
    return ret;
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Response>
  inline Response* GetResponse( XRootDStatus *status, AnyObject *rsp )
  {
    return status->IsOK() ? GetResponse<Response>( rsp ) : nullptr;
  }
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Response>
  class FunctionWrapper: public ResponseHandler
  {
    public:
 
      //------------------------------------------------------------------------
      //
      //------------------------------------------------------------------------
      FunctionWrapper(
          std::function<void( XRootDStatus&, Response& )> handleFunction ) :
          fun( [handleFunction]( XRootDStatus &s, Response &r, HostList& ){ handleFunction( s, r ); } )
      {
      }
 
      //------------------------------------------------------------------------
      //
      //------------------------------------------------------------------------
      FunctionWrapper(
          std::function<void( XRootDStatus&, Response&, HostList& )> handleFunction ) :
          fun( handleFunction )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponseWithHosts( XRootDStatus *status, AnyObject *response, HostList *hostList )
      {
        std::unique_ptr<XRootDStatus> delst( status );
        std::unique_ptr<AnyObject> delrsp( response );
        std::unique_ptr<HostList> delhl( hostList );
        if (Response *res = GetResponse<Response>( status, response ))
          fun( *status, *res, *hostList );
        else {
          Response dummy;
          fun( *status, dummy, *hostList );
        }
      }
 
    private:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::function<void( XRootDStatus&, Response&, HostList& )> fun;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<>
  class FunctionWrapper<void> : public ResponseHandler
  {
    public:
 
      //------------------------------------------------------------------------
      //
      //------------------------------------------------------------------------
      FunctionWrapper(
          std::function<void( XRootDStatus& )> handleFunction ) :
          fun( [handleFunction]( XRootDStatus& s, HostList& ){ handleFunction( s ); } )
      {
      }
 
      //------------------------------------------------------------------------
      //
      //------------------------------------------------------------------------
      FunctionWrapper(
          std::function<void( XRootDStatus&, HostList& )> handleFunction ) :
          fun( handleFunction )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponseWithHosts( XRootDStatus *status, AnyObject *response, HostList *hostList )
      {
        std::unique_ptr<XRootDStatus> delst( status );
        std::unique_ptr<AnyObject> delrsp( response );
        std::unique_ptr<HostList> delhl( hostList );
        fun( *status, *hostList );
      }
 
    private:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::function<void( XRootDStatus&, HostList& )> fun;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Response, typename Return>
  class TaskWrapper: public ResponseHandler
  {
    public:
 
      //------------------------------------------------------------------------
      //
      //------------------------------------------------------------------------
      TaskWrapper( std::packaged_task<Return( XRootDStatus&, Response& )> && task ) :
        task( std::move( task ) )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponse( XRootDStatus *status, AnyObject *response )
      {
        std::unique_ptr<XRootDStatus> delst( status );
        std::unique_ptr<AnyObject> delrsp( response );
        if (Response *resp = GetResponse<Response>( status, response )) {
          task( *status, *resp );
        } else {
          Response dummy;
          task( *status, dummy );
        }
      }
 
    private:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::packaged_task<Return( XRootDStatus&, Response& )> task;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Return>
  class TaskWrapper<void, Return>: public ResponseHandler
  {
    public:
 
      //------------------------------------------------------------------------
      //
      //------------------------------------------------------------------------
      TaskWrapper( std::packaged_task<Return( XRootDStatus& )> && task ) :
        task( std::move( task ) )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponse( XRootDStatus *status, AnyObject *response )
      {
        std::unique_ptr<XRootDStatus> delst( status );
        std::unique_ptr<AnyObject> delrsp( response );
        task( *status );
      }
 
    private:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::packaged_task<Return( XRootDStatus& )> task;
  };
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class ExOpenFuncWrapper: public ResponseHandler
  {
    public:
 
      //------------------------------------------------------------------------
      //
      //------------------------------------------------------------------------
      ExOpenFuncWrapper( const Ctx<File> &f,
          std::function<void( XRootDStatus&, StatInfo& )> handleFunction ) :
          f( f ), fun( [handleFunction]( XRootDStatus &s, StatInfo &i, HostList& ){ handleFunction( s, i ); } )
      {
      }
 
      //------------------------------------------------------------------------
      //
      //------------------------------------------------------------------------
      ExOpenFuncWrapper( const Ctx<File> &f,
          std::function<void( XRootDStatus&, StatInfo&, HostList& )> handleFunction ) :
          f( f ), fun( handleFunction )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponseWithHosts( XRootDStatus *status, AnyObject *response, HostList *hostList )
      {
        std::unique_ptr<XRootDStatus> delst( status );
        std::unique_ptr<AnyObject> delrsp( response );
        std::unique_ptr<HostList> delhl( hostList );
 
        if( !status->IsOK() ) {
          StatInfo dummy{};
          fun( *status, dummy, *hostList );
          return;
        }
 
        StatInfo *info = nullptr;
        XRootDStatus st = f->Stat( false, info );
        fun( *status, *info, *hostList );
        delete info;
      }
 
    private:
      Ctx<File> f;
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::function<void( XRootDStatus&, StatInfo&, HostList& )> fun;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class PipelineException : public std::exception
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      PipelineException( const XRootDStatus &error ) : error( error ), strerr( error.ToString() )
      {
 
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      PipelineException( const PipelineException &ex ) : error( ex.error ), strerr( ex.error.ToString() )
      {
 
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      PipelineException& operator=( const PipelineException &ex )
      {
        error  = ex.error;
        strerr = ex.strerr;
        return *this;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const char* what() const noexcept
      {
        return strerr.c_str();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const XRootDStatus& GetError() const
      {
        return error;
      }
 
    private:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus error;
      std::string  strerr;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Response>
  class FutureWrapperBase : public ResponseHandler
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FutureWrapperBase( std::future<Response> &ftr ) : fulfilled( false )
      {
        ftr = prms.get_future();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~FutureWrapperBase()
      {
        if( !fulfilled ) SetException( XRootDStatus( stError, errPipelineFailed ) );
      }
 
    protected:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline void SetException( const XRootDStatus &err )
      {
        std::exception_ptr ex = std::make_exception_ptr( PipelineException( err ) );
        prms.set_exception( ex );
        fulfilled = true;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::promise<Response> prms;
      bool                   fulfilled;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Response>
  class FutureWrapper : public FutureWrapperBase<Response>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FutureWrapper( std::future<Response> &ftr ) : FutureWrapperBase<Response>( ftr )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponse( XRootDStatus *status, AnyObject *response )
      {
        std::unique_ptr<XRootDStatus> delst( status );
        std::unique_ptr<AnyObject> delrsp( response );
        if( status->IsOK() ) {
          if(Response *resp = GetResponse<Response>( response )) {
            this->prms.set_value( std::move( *resp ) );
            this->fulfilled = true;
          } else {
            this->SetException( XRootDStatus( stError, errInternal ) );
          }
        } else {
          this->SetException( *status );
        }
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<>
  class FutureWrapper<void> : public FutureWrapperBase<void>
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      FutureWrapper( std::future<void> &ftr ) : FutureWrapperBase<void>( ftr )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void HandleResponse( XRootDStatus *status, AnyObject *response )
      {
        std::unique_ptr<XRootDStatus> delst( status );
        std::unique_ptr<AnyObject> delrsp( response );
        if( status->IsOK() )
        {
          prms.set_value();
          fulfilled = true;
        }
        else
          SetException( *status );
      }
  };
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class RawWrapper : public ResponseHandler
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      RawWrapper( ResponseHandler *handler ) : handler( handler )
      {
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void HandleResponseWithHosts( XRootDStatus *status,
                                            AnyObject    *response,
                                            HostList     *hostList )
      {
        handler->HandleResponseWithHosts( status, response, hostList );
      }
 
    private:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ResponseHandler *handler;
  };
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Response>
  struct RespBase
  {
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static ResponseHandler* Create( ResponseHandler *hdlr )
      {
        return new RawWrapper( hdlr );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static ResponseHandler* Create( ResponseHandler &hdlr )
      {
        return new RawWrapper( &hdlr );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static ResponseHandler* Create( std::future<Response> &ftr )
      {
        return new FutureWrapper<Response>( ftr );
      }
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename Response>
  struct Resp: RespBase<Response>
  {
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static ResponseHandler* Create( std::function<void( XRootDStatus&,
          Response& )> func )
      {
        return new FunctionWrapper<Response>( func );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static ResponseHandler* Create( std::function<void( XRootDStatus&,
          Response&, HostList& )> func )
      {
        return new FunctionWrapper<Response>( func );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<typename Return>
      inline static ResponseHandler* Create( std::packaged_task<Return( XRootDStatus&,
          Response& )> &task )
      {
        return new TaskWrapper<Response, Return>( std::move( task ) );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using RespBase<Response>::Create;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<>
  struct Resp<void>: RespBase<void>
  {
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static ResponseHandler* Create( std::function<void( XRootDStatus& )> func )
      {
        return new FunctionWrapper<void>( func );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      inline static ResponseHandler* Create( std::function<void( XRootDStatus&, HostList& )> func )
      {
        return new FunctionWrapper<void>( func );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<typename Return>
      inline static ResponseHandler* Create( std::packaged_task<Return( XRootDStatus& )> &task )
      {
        return new TaskWrapper<void, Return>( std::move( task ) );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      using RespBase<void>::Create;
  };
}
 
#endif // __XRD_CL_OPERATIONS_HANDLERS_HH__