XrdClMessageUtils.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// Copyright (c) 2011-2012 by European Organization for Nuclear Research (CERN)
// Author: Lukasz Janyst <ljanyst@cern.ch>
//------------------------------------------------------------------------------
// 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/>.
//------------------------------------------------------------------------------

#ifndef __XRD_CL_MESSAGE_UTILS_HH__
#define __XRD_CL_MESSAGE_UTILS_HH__

#include "XrdCl/XrdClXRootDResponses.hh"
#include "XrdCl/XrdClURL.hh"
#include "XrdCl/XrdClMessage.hh"
#include "XrdSys/XrdSysPthread.hh"
#include <memory>

namespace XrdCl
{
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class SyncResponseHandler: public ResponseHandler
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      SyncResponseHandler():
        pStatus(0),
        pResponse(0),
        pSem( new XrdSysSemaphore(0) ) {}

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~SyncResponseHandler()
      {
        delete pSem;
      }


      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void HandleResponse( XRootDStatus *status,
                                   AnyObject    *response )
      {
        pStatus = status;
        pResponse = response;
        pSem->Post();
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      XRootDStatus *GetStatus()
      {
        return pStatus;
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      AnyObject *GetResponse()
      {
        return pResponse;
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void WaitForResponse()
      {
        pSem->Wait();
      }

    private:
      XRootDStatus    *pStatus;
      AnyObject       *pResponse;
      XrdSysSemaphore *pSem;
  };

  //----------------------------------------------------------------------------
  // Sending parameters
  //----------------------------------------------------------------------------
  struct MessageSendParams
  {
    MessageSendParams():
      timeout(0), expires(0), followRedirects(true), stateful(true),
      hostList(0), chunkList(0), redirectLimit(0) {}
    uint16_t         timeout;
    time_t           expires;
    const HostInfo   loadBalancer;
    bool             followRedirects;
    bool             stateful;
    HostList        *hostList;
    ChunkList       *chunkList;
    uint16_t         redirectLimit;
  };

  class MessageUtils
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static XRootDStatus WaitForStatus( SyncResponseHandler *handler )
      {
        handler->WaitForResponse();
        XRootDStatus *status = handler->GetStatus();
        XRootDStatus ret( *status );
        delete status;
        return ret;
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<class Type>
      static XrdCl::XRootDStatus WaitForResponse(
                            SyncResponseHandler  *handler,
                            Type                *&response )
      {
        handler->WaitForResponse();

        std::auto_ptr<AnyObject> resp( handler->GetResponse() );
        XRootDStatus *status = handler->GetStatus();
        XRootDStatus ret( *status );
        delete status;

        if( ret.IsOK() )
        {
          if( !resp.get() )
            return XRootDStatus( stError, errInternal );
          resp->Get( response );
          resp->Set( (int *)0 );
          if( !response )
            return XRootDStatus( stError, errInternal );
        }

        return ret;
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      template<class Type>
      static void CreateRequest( Message  *&msg,
                                 Type     *&req,
                                 uint32_t  payloadSize = 0 )
      {
        msg = new Message( sizeof(Type)+payloadSize );
        req = (Type*)msg->GetBuffer();
        msg->Zero();
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static Status SendMessage( const URL               &url,
                                 Message                 *msg,
                                 ResponseHandler         *handler,
                                 const MessageSendParams &sendParams );

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static void ProcessSendParams( MessageSendParams &sendParams );

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static void AppendCGI( Message              *msg,
                             const URL::ParamsMap &newCgi,
                             bool                  replace );

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      static void MergeCGI( URL::ParamsMap       &cgi1,
                            const URL::ParamsMap &cgi2,
                            bool                  replace );                             
  };
}

#endif // __XRD_CL_MESSAGE_UTILS_HH__