XrdCl::MessageUtils Class Reference

#include <XrdClMessageUtils.hh>

Collaboration diagram for XrdCl::MessageUtils:

Static Public Member Functions
template<class Request>
static void	CreateRequest (Message *&msg, Request *&req, uint32_t payloadSize=0)
	Create a message.
template<typename T>
static Status	CreateXAttrBody (Message *msg, const std::vector< T > &vec, const std::string &path="")
static Status	CreateXAttrVec (const std::vector< std::string > &attrs, std::vector< char > &nvec)
static Status	CreateXAttrVec (const std::vector< xattr_t > &attrs, std::vector< char > &avec)
	Create xattr vector.
static void	MergeCGI (URL::ParamsMap &cgi1, const URL::ParamsMap &cgi2, bool replace)
	Merge cgi2 into cgi1.
static void	ProcessSendParams (MessageSendParams &sendParams)
	Process sending params.
static Status	RedirectMessage (const URL &url, Message *msg, ResponseHandler *handler, MessageSendParams &sendParams, LocalFileHandler *lFileHandler)
	Redirect message.
static void	RewriteCGIAndPath (Message *msg, const URL::ParamsMap &newCgi, bool replace, const std::string &newPath, std::string *opathp=nullptr)
	Append cgi to the one already present in the message.
static XRootDStatus	SendMessage (const URL &url, Message *msg, ResponseHandler *handler, MessageSendParams &sendParams, LocalFileHandler *lFileHandler)
	Send message.
template<class Type>
static XrdCl::XRootDStatus	WaitForResponse (SyncResponseHandler *handler, Type *&response)
	Wait for the response.
static XRootDStatus	WaitForStatus (SyncResponseHandler *handler)
	Wait and return the status of the query.

Detailed Description

Definition at line 149 of file XrdClMessageUtils.hh.

Member Function Documentation

CreateRequest()

template<class Request>

void XrdCl::MessageUtils::CreateRequest ( Message *& msg, Request *& req, uint32_t payloadSize = 0 )

inlinestatic

Create a message.

Definition at line 198 of file XrdClMessageUtils.hh.

      {
          msg = new Message( sizeof(Request) +  payloadSize );
          req = (Request*)msg->GetBuffer();
          msg->Zero();
      }

References XrdCl::Buffer::GetBuffer(), and XrdCl::Buffer::Zero().

Referenced by XrdCl::FileStateHandler::Checkpoint(), XrdCl::FileStateHandler::ChkptWrt(), XrdCl::FileStateHandler::ChkptWrtV(), XrdCl::FileSystem::ChMod(), XrdCl::FileStateHandler::Clone(), XrdCl::FileStateHandler::Close(), XrdCl::FileSystem::DirList(), XrdCl::FileStateHandler::Fcntl(), XrdCl::FileSystem::Locate(), XrdCl::FileSystem::MkDir(), XrdCl::FileSystem::Mv(), XrdCl::FileStateHandler::PgReadImpl(), XrdCl::FileStateHandler::PgWriteImpl(), XrdCl::FileSystem::Ping(), XrdCl::FileSystem::Prepare(), XrdCl::FileStateHandler::PreRead(), XrdCl::FileSystem::Protocol(), XrdCl::FileSystem::Query(), XrdCl::FileStateHandler::Read(), XrdCl::FileStateHandler::ReadV(), XrdCl::FileSystem::Rm(), XrdCl::FileSystem::RmDir(), XrdCl::FileStateHandler::Stat(), XrdCl::FileSystem::Stat(), XrdCl::FileSystem::StatVFS(), XrdCl::FileStateHandler::Sync(), XrdCl::FileStateHandler::Truncate(), XrdCl::FileSystem::Truncate(), XrdCl::FileStateHandler::VectorRead(), XrdCl::FileStateHandler::VectorWrite(), XrdCl::FileStateHandler::Visa(), XrdCl::FileStateHandler::Write(), and XrdCl::FileStateHandler::WriteV().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateXAttrBody()

template<typename T>

Status XrdCl::MessageUtils::CreateXAttrBody ( Message * msg, const std::vector< T > & vec, const std::string & path = "" )

inlinestatic

Create body of xattr request and set the body size

Parameters

msg	: the request
vec	: the argument
path	: file path

Definition at line 289 of file XrdClMessageUtils.hh.

      {
        ClientRequestHdr *hdr = reinterpret_cast<ClientRequestHdr*>( msg->GetBuffer() );
 
        std::vector<char> xattrvec;
        Status st = MessageUtils::CreateXAttrVec( vec, xattrvec );
        if( !st.IsOK() )
          return st;
 
        // update body size in the header
        hdr->dlen  = path.size() + 1;
        hdr->dlen += xattrvec.size();
 
        // append the body
        size_t offset = sizeof( ClientRequestHdr );
        msg->Append( path.c_str(), path.size() + 1, offset );
        offset += path.size() + 1;
        msg->Append( xattrvec.data(), xattrvec.size(), offset );
 
        return Status();
      }

References XrdCl::Buffer::Append(), CreateXAttrVec(), ClientRequestHdr::dlen, XrdCl::Buffer::GetBuffer(), and XrdCl::Status::IsOK().

Here is the call graph for this function:

CreateXAttrVec() [1/2]

Status XrdCl::MessageUtils::CreateXAttrVec ( const std::vector< std::string > & attrs, std::vector< char > & nvec )

static

Create xattr name vector vector

Parameters

attrs	: extended attribute name list
nvec	: vector containing the name vector

Definition at line 458 of file XrdClMessageUtils.cc.

  {
    if( attrs.empty() )
      return Status();
 
    if( attrs.size() > xfaLimits::kXR_faMaxVars )
      return Status( stError, errInvalidArgs );
 
    //----------------------------------------------------------------------
    // Calculate the name and value vector lengths
    //----------------------------------------------------------------------
 
    // 2 bytes for rc + 1 byte for null character at the end
    static const int name_overhead  = 3;
 
    size_t nlen = 0;
    for( auto itr = attrs.begin(); itr != attrs.end(); ++itr )
      nlen += itr->size() + name_overhead;
 
    if( nlen > xfaLimits::kXR_faMaxNlen )
      return Status( stError, errInvalidArgs );
 
    //----------------------------------------------------------------------
    // Create name vector
    //----------------------------------------------------------------------
    nvec.resize( nlen, 0 );
    char *nptr = nvec.data();
 
    for( auto itr = attrs.begin(); itr != attrs.end(); ++itr )
      nptr = ClientFattrRequest::NVecInsert( itr->c_str(), nptr );
 
    return Status();
  }

References XrdCl::errInvalidArgs, kXR_faMaxNlen, kXR_faMaxVars, ClientFattrRequest::NVecInsert(), and XrdCl::stError.

Here is the call graph for this function:

CreateXAttrVec() [2/2]

Status XrdCl::MessageUtils::CreateXAttrVec ( const std::vector< xattr_t > & attrs, std::vector< char > & avec )

static

Create xattr vector.

Create xattr vector

Parameters

attrs	: extended attribute list
avec	: vector containing the name vector and the value vector

Definition at line 407 of file XrdClMessageUtils.cc.

  {
    if( attrs.empty() )
      return Status();
 
    if( attrs.size() > xfaLimits::kXR_faMaxVars )
      return Status( stError, errInvalidArgs );
 
    //----------------------------------------------------------------------
    // Calculate the name and value vector lengths
    //----------------------------------------------------------------------
 
    // 2 bytes for rc + 1 byte for null character at the end
    static const int name_overhead  = 3;
    // 4 bytes for value length
    static const int value_overhead = 4;
 
    size_t nlen = 0, vlen = 0;
    for( auto itr = attrs.begin(); itr != attrs.end(); ++itr )
    {
      nlen += std::get<xattr_name>( *itr ).size() + name_overhead;
      vlen += std::get<xattr_value>( *itr ).size() + value_overhead;
    }
 
    if( nlen > xfaLimits::kXR_faMaxNlen )
      return Status( stError, errInvalidArgs );
 
    if( vlen > xfaLimits::kXR_faMaxVlen )
      return Status( stError, errInvalidArgs );
 
    //----------------------------------------------------------------------
    // Create name and value vectors
    //----------------------------------------------------------------------
    avec.resize( nlen + vlen, 0 );
    char *nvec = avec.data(), *vvec = avec.data() + nlen;
 
    for( auto itr = attrs.begin(); itr != attrs.end(); ++itr )
    {
      const std::string &name = std::get<xattr_name>( *itr );
      nvec = ClientFattrRequest::NVecInsert( name.c_str(), nvec );
      const std::string &value = std::get<xattr_value>( *itr );
      vvec = ClientFattrRequest::VVecInsert( value.c_str(), vvec );
    }
 
    return Status();
  }

References XrdCl::errInvalidArgs, kXR_faMaxNlen, kXR_faMaxVars, kXR_faMaxVlen, ClientFattrRequest::NVecInsert(), XrdCl::stError, and ClientFattrRequest::VVecInsert().

Referenced by CreateXAttrBody().

Here is the call graph for this function:

Here is the caller graph for this function:

MergeCGI()

void XrdCl::MessageUtils::MergeCGI ( URL::ParamsMap & cgi1, const URL::ParamsMap & cgi2, bool replace )

static

Merge cgi2 into cgi1.

Merge cgi2 into cgi1

Parameters

cgi1	cgi to be merged into
cgi2	cgi to be merged in
replace	indicates whether, in case of a conflict, the new CGI parameter should replace an existing one or be appended to it using a comma

Definition at line 381 of file XrdClMessageUtils.cc.

  {
    URL::ParamsMap::const_iterator it;
    for( it = cgi2.begin(); it != cgi2.end(); ++it )
    {
      if( replace || cgi1.find( it->first ) == cgi1.end() )
        cgi1[it->first] = it->second;
      else
      {
        std::string &v = cgi1[it->first];
        if( v.empty() )
          v = it->second;
        else
        {
          v += ',';
          v += it->second;
        }
      }
    }
  }

Referenced by XrdCl::FileStateHandler::OnOpen(), XrdCl::FileStateHandler::OnStateRedirection(), RewriteCGIAndPath(), and XrdCl::FileStateHandler::TryOtherServer().

Here is the caller graph for this function:

ProcessSendParams()

void XrdCl::MessageUtils::ProcessSendParams ( MessageSendParams & sendParams )

static

Process sending params.

Definition at line 220 of file XrdClMessageUtils.cc.

  {
    //--------------------------------------------------------------------------
    // Timeout
    //--------------------------------------------------------------------------
    Env *env = DefaultEnv::GetEnv();
    if( sendParams.timeout == 0 )
    {
      int requestTimeout = DefaultRequestTimeout;
      env->GetInt( "RequestTimeout", requestTimeout );
      sendParams.timeout = requestTimeout;
    }
 
    if( sendParams.expires == 0 )
      sendParams.expires = ::time(0)+sendParams.timeout;
 
    //--------------------------------------------------------------------------
    // Redirect limit
    //--------------------------------------------------------------------------
    if( sendParams.redirectLimit == 0 )
    {
      int redirectLimit = DefaultRedirectLimit;
      env->GetInt( "RedirectLimit", redirectLimit );
      sendParams.redirectLimit = redirectLimit;
    }
  }

References XrdCl::DefaultRedirectLimit, XrdCl::DefaultRequestTimeout, XrdCl::MessageSendParams::expires, XrdCl::DefaultEnv::GetEnv(), XrdCl::Env::GetInt(), XrdCl::MessageSendParams::redirectLimit, and XrdCl::MessageSendParams::timeout.

Referenced by XrdCl::FileStateHandler::Checkpoint(), XrdCl::FileStateHandler::ChkptWrt(), XrdCl::FileStateHandler::ChkptWrtV(), XrdCl::FileSystem::ChMod(), XrdCl::FileStateHandler::Clone(), XrdCl::FileStateHandler::Close(), XrdCl::FileSystem::DirList(), XrdCl::FileStateHandler::Fcntl(), XrdCl::FileSystem::Locate(), XrdCl::FileSystem::MkDir(), XrdCl::FileSystem::Mv(), XrdCl::FileStateHandler::PgReadImpl(), XrdCl::FileStateHandler::PgWriteImpl(), XrdCl::FileSystem::Ping(), XrdCl::FileSystem::Prepare(), XrdCl::FileStateHandler::PreRead(), XrdCl::FileSystem::Protocol(), XrdCl::FileSystem::Query(), XrdCl::FileStateHandler::Read(), XrdCl::FileStateHandler::ReadV(), XrdCl::FileSystem::Rm(), XrdCl::FileSystem::RmDir(), XrdCl::FileStateHandler::Stat(), XrdCl::FileSystem::Stat(), XrdCl::FileSystem::StatVFS(), XrdCl::FileStateHandler::Sync(), XrdCl::FileStateHandler::Truncate(), XrdCl::FileSystem::Truncate(), XrdCl::FileStateHandler::VectorRead(), XrdCl::FileStateHandler::VectorWrite(), XrdCl::FileStateHandler::Visa(), XrdCl::FileStateHandler::Write(), and XrdCl::FileStateHandler::WriteV().

Here is the call graph for this function:

Here is the caller graph for this function:

RedirectMessage()

Status XrdCl::MessageUtils::RedirectMessage ( const URL & url, Message * msg, ResponseHandler * handler, MessageSendParams & sendParams, LocalFileHandler * lFileHandler )

static

Redirect message.

Definition at line 150 of file XrdClMessageUtils.cc.

  {
    //--------------------------------------------------------------------------
    // Register a new virtual redirector
    //--------------------------------------------------------------------------
    RedirectorRegistry& registry = RedirectorRegistry::Instance();
    Status st = registry.Register( url );
    if( !st.IsOK() )
      return st;
 
    //--------------------------------------------------------------------------
    // Get the stuff needed to send the message
    //--------------------------------------------------------------------------
    Log        *log        = DefaultEnv::GetLog();
    PostMaster *postMaster = DefaultEnv::GetPostMaster();
 
    if( !postMaster )
      return Status( stError, errUninitialized );
 
    log->Dump( XRootDMsg, "[%s] Redirecting message %s",
               url.GetHostId().c_str(), msg->GetObfuscatedDescription().c_str() );
 
    XRootDTransport::MarshallRequest( msg );
 
    //--------------------------------------------------------------------------
    // Create and set up the message handler
    //--------------------------------------------------------------------------
    XRootDMsgHandler *msgHandler;
    msgHandler = new XRootDMsgHandler( msg, handler, &url, std::shared_ptr<SIDManager>(), lFileHandler );
    msgHandler->SetExpiration( sendParams.expires );
    msgHandler->SetRedirectAsAnswer( !sendParams.followRedirects );
    msgHandler->SetOksofarAsAnswer( sendParams.chunkedResponse );
    msgHandler->SetChunkList( sendParams.chunkList );
    msgHandler->SetRedirectCounter( sendParams.redirectLimit );
    msgHandler->SetFollowMetalink( true );
 
    HostInfo info( url, true );
    info.flags = kXR_isManager | kXR_attrMeta | kXR_attrVirtRdr;
    sendParams.loadBalancer = info;
    msgHandler->SetLoadBalancer( info );
 
    HostList *list = 0;
    list = new HostList();
    list->push_back( info );
    msgHandler->SetHostList( list );
 
    //--------------------------------------------------------------------------
    // Redirect the message
    //--------------------------------------------------------------------------
    st = postMaster->Redirect( url, msg, msgHandler );
    if( !st.IsOK() )
    {
      XRootDTransport::UnMarshallRequest( msg );
      log->Error( XRootDMsg, "[%s] Unable to send the message %s: %s",
                  url.GetHostId().c_str(), msg->GetObfuscatedDescription().c_str(),
                  st.ToString().c_str() );
      delete msgHandler;
      delete list;
      return st;
    }
    return Status();
  }

References XrdCl::MessageSendParams::chunkedResponse, XrdCl::MessageSendParams::chunkList, XrdCl::Log::Dump(), XrdCl::Log::Error(), XrdCl::errUninitialized, XrdCl::MessageSendParams::expires, XrdCl::HostInfo::flags, XrdCl::MessageSendParams::followRedirects, XrdCl::URL::GetHostId(), XrdCl::DefaultEnv::GetLog(), XrdCl::Message::GetObfuscatedDescription(), XrdCl::DefaultEnv::GetPostMaster(), XrdCl::RedirectorRegistry::Instance(), XrdCl::Status::IsOK(), kXR_attrMeta, kXR_attrVirtRdr, kXR_isManager, XrdCl::MessageSendParams::loadBalancer, XrdCl::XRootDTransport::MarshallRequest(), XrdCl::PostMaster::Redirect(), XrdCl::MessageSendParams::redirectLimit, XrdCl::RedirectorRegistry::Register(), XrdCl::XRootDMsgHandler::SetChunkList(), XrdCl::XRootDMsgHandler::SetExpiration(), XrdCl::XRootDMsgHandler::SetFollowMetalink(), XrdCl::XRootDMsgHandler::SetHostList(), XrdCl::XRootDMsgHandler::SetLoadBalancer(), XrdCl::XRootDMsgHandler::SetOksofarAsAnswer(), XrdCl::XRootDMsgHandler::SetRedirectAsAnswer(), XrdCl::XRootDMsgHandler::SetRedirectCounter(), XrdCl::stError, XrdCl::Status::ToString(), XrdCl::XRootDTransport::UnMarshallRequest(), and XrdCl::XRootDMsg.

Here is the call graph for this function:

RewriteCGIAndPath()

void XrdCl::MessageUtils::RewriteCGIAndPath ( Message * msg, const URL::ParamsMap & newCgi, bool replace, const std::string & newPath, std::string * opathp = nullptr )

static

Append cgi to the one already present in the message.

Rewrite CGI and path if necessary

Parameters

msg	message concerned
newCgi	the new cgi
replace	indicates whether, in case of a conflict, the new CGI parameter should replace an existing one or be appended to it using a comma
newPath	will be used as the new destination path if it is not empty
opathp	if not null will be filled with the initial path contained in the message, before it is set to newPath

Definition at line 250 of file XrdClMessageUtils.cc.

  {
    ClientRequest  *req = (ClientRequest *)msg->GetBuffer();
    switch( req->header.requestid )
    {
      case kXR_chmod:
      case kXR_mkdir:
      case kXR_mv:
      case kXR_open:
      case kXR_rm:
      case kXR_rmdir:
      case kXR_stat:
      case kXR_truncate:
      {
        //----------------------------------------------------------------------
        // Get the pointer to the appropriate path
        //----------------------------------------------------------------------
        char *path = msg->GetBuffer( 24 );
        size_t length = req->header.dlen;
        if( req->header.requestid == kXR_mv )
        {
          for( int i = 0; i < req->header.dlen; ++i, ++path, --length )
            if( *path == ' ' )
              break;
          ++path;
          --length;
        }
 
        //----------------------------------------------------------------------
        // Create a fake URL from an existing CGI
        //----------------------------------------------------------------------
        char *pathWithNull = new char[length+1];
        memcpy( pathWithNull, path, length );
        pathWithNull[length] = 0;
        std::ostringstream o;
        o << "fake://fake:111/" << pathWithNull;
        delete [] pathWithNull;
 
        URL currentPath( o.str() );
        URL::ParamsMap currentCgi = currentPath.GetParams();
        MergeCGI( currentCgi, newCgi, replace );
        currentPath.SetParams( currentCgi );
        if( opathp )
          *opathp = currentPath.GetPath();
        if( !newPath.empty() )
          currentPath.SetPath( newPath );
        std::string newPathWitParams = currentPath.GetPathWithFilteredParams();
 
        //----------------------------------------------------------------------
        // Write the path with the new cgi appended to the message
        //----------------------------------------------------------------------
        uint32_t newDlen = req->header.dlen - length + newPathWitParams.size();
        msg->ReAllocate( 24+newDlen );
        req  = (ClientRequest *)msg->GetBuffer();
        path = msg->GetBuffer( 24 );
        if( req->header.requestid == kXR_mv )
        {
          for( int i = 0; i < req->header.dlen; ++i, ++path )
            if( *path == ' ' )
              break;
          ++path;
        }
        memcpy( path, newPathWitParams.c_str(), newPathWitParams.size() );
        req->header.dlen = newDlen;
        break;
      }
      case kXR_locate:
      {
        Env *env = DefaultEnv::GetEnv();
        int preserveLocateTried = DefaultPreserveLocateTried;
        env->GetInt( "PreserveLocateTried", preserveLocateTried );
 
        if( !preserveLocateTried ) break;
 
        //----------------------------------------------------------------------
        // In case of locate we only want to preserve tried/triedrc CGI info
        //----------------------------------------------------------------------
        URL::ParamsMap triedCgi;
        URL::ParamsMap::const_iterator itr = newCgi.find( "triedrc" );
        if( itr != newCgi.end() )
          triedCgi[itr->first] = itr->second;
        itr = newCgi.find( "tried" );
        if( itr != newCgi.end() )
          triedCgi[itr->first] = itr->second;
 
        //----------------------------------------------------------------------
        // Is there anything to do?
        //----------------------------------------------------------------------
        if( triedCgi.empty() ) break;
 
        //----------------------------------------------------------------------
        // Get the pointer to the appropriate path
        //----------------------------------------------------------------------
        char *path = msg->GetBuffer( 24 );
        size_t length = req->header.dlen;
 
        //----------------------------------------------------------------------
        // Create a fake URL from an existing CGI
        //----------------------------------------------------------------------
        std::string strpath( path, length );
        std::ostringstream o;
        o << "fake://fake:111/" << strpath;
 
        URL currentPath( o.str() );
        URL::ParamsMap currentCgi = currentPath.GetParams();
        MergeCGI( currentCgi, triedCgi, replace );
        currentPath.SetParams( currentCgi );
        std::string pathWitParams = currentPath.GetPathWithFilteredParams();
 
        //----------------------------------------------------------------------
        // Write the path with the new cgi appended to the message
        //----------------------------------------------------------------------
        uint32_t newDlen = pathWitParams.size();
        msg->ReAllocate( 24+newDlen );
        req  = (ClientRequest *)msg->GetBuffer();
        path = msg->GetBuffer( 24 );
        memcpy( path, pathWitParams.c_str(), pathWitParams.size() );
        req->header.dlen = newDlen;
        break;
      }
    }
    XRootDTransport::SetDescription( msg );
  }

References XrdCl::DefaultPreserveLocateTried, ClientRequestHdr::dlen, XrdCl::Buffer::GetBuffer(), XrdCl::DefaultEnv::GetEnv(), XrdCl::Env::GetInt(), XrdCl::URL::GetParams(), XrdCl::URL::GetPath(), XrdCl::URL::GetPathWithFilteredParams(), ClientRequest::header, kXR_chmod, kXR_locate, kXR_mkdir, kXR_mv, kXR_open, kXR_rm, kXR_rmdir, kXR_stat, kXR_truncate, MergeCGI(), XrdCl::Buffer::ReAllocate(), ClientRequestHdr::requestid, XrdCl::XRootDTransport::SetDescription(), XrdCl::URL::SetParams(), and XrdCl::URL::SetPath().

Here is the call graph for this function:

SendMessage()

XRootDStatus XrdCl::MessageUtils::SendMessage ( const URL & url, Message * msg, ResponseHandler * handler, MessageSendParams & sendParams, LocalFileHandler * lFileHandler )

static

Send message.

Definition at line 43 of file XrdClMessageUtils.cc.

  {
    //--------------------------------------------------------------------------
    // Get the stuff needed to send the message
    //--------------------------------------------------------------------------
    Log        *log        = DefaultEnv::GetLog();
    PostMaster *postMaster = DefaultEnv::GetPostMaster();
    XRootDStatus      st;
 
    if( !postMaster )
      return XRootDStatus( stError, errUninitialized );
 
    log->Dump( XRootDMsg, "[%s] Sending message %s",
               url.GetHostId().c_str(), msg->GetObfuscatedDescription().c_str() );
 
    //--------------------------------------------------------------------------
    // Get an instance of SID manager object
    //--------------------------------------------------------------------------
    std::shared_ptr<SIDManager> sidMgr( SIDMgrPool::Instance().GetSIDMgr( url ) );
    ClientRequestHdr *req = (ClientRequestHdr*)msg->GetBuffer();
 
    //--------------------------------------------------------------------------
    // Allocate the SID and marshall the message
    //--------------------------------------------------------------------------
    st = sidMgr->AllocateSID( req->streamid );
    if( !st.IsOK() )
    {
      log->Error( XRootDMsg, "[%s] Unable to allocate stream id",
                             url.GetHostId().c_str() );
      return st;
    }
 
    //--------------------------------------------------------------------------
    // Make sure that in case of checkpoint xeq request the embedded request
    // SID is matching
    //--------------------------------------------------------------------------
    if( req->requestid == kXR_chkpoint )
    {
      ClientRequest *r = (ClientRequest*)req;
      if( r->chkpoint.opcode == kXR_ckpXeq )
      {
        ClientRequest *xeq = (ClientRequest*) msg->GetBuffer( sizeof( ClientChkPointRequest ) );
        xeq->header.streamid[0] = req->streamid[0];
        xeq->header.streamid[1] = req->streamid[1];
      }
    }
 
    XRootDTransport::MarshallRequest( msg );
 
    //--------------------------------------------------------------------------
    // Create and set up the message handler
    //--------------------------------------------------------------------------
    XRootDMsgHandler *msgHandler;
    msgHandler = new XRootDMsgHandler( msg, handler, &url, sidMgr, lFileHandler );
    msgHandler->SetExpiration( sendParams.expires );
    msgHandler->SetRedirectAsAnswer( !sendParams.followRedirects );
    msgHandler->SetOksofarAsAnswer( sendParams.chunkedResponse );
    msgHandler->SetChunkList( sendParams.chunkList );
    msgHandler->SetKernelBuffer( sendParams.kbuff );
    msgHandler->SetRedirectCounter( sendParams.redirectLimit );
    msgHandler->SetStateful( sendParams.stateful );
    msgHandler->SetCrc32cDigests( std::move( sendParams.crc32cDigests ) );
 
    if( sendParams.loadBalancer.url.IsValid() )
      msgHandler->SetLoadBalancer( sendParams.loadBalancer );
 
    HostList *list = 0;
    if( sendParams.hostList )
    {
      list = sendParams.hostList;
      sendParams.hostList = nullptr;
    }
    else
      list = new HostList();
    list->push_back( url );
    msgHandler->SetHostList( list );
 
    //--------------------------------------------------------------------------
    // Send the message
    //--------------------------------------------------------------------------
    st = postMaster->Send( url, msg, msgHandler, sendParams.stateful,
                           sendParams.expires );
    if( !st.IsOK() )
    {
      XRootDTransport::UnMarshallRequest( msg );
      log->Error( XRootDMsg, "[%s] Unable to send the message %s: %s",
                  url.GetHostId().c_str(), msg->GetObfuscatedDescription().c_str(),
                  st.ToString().c_str() );
 
      // we need to reassign req as its current value might have been
      // invalidated in the meanwhile due to a realloc
      req = (ClientRequestHdr*)msg->GetBuffer();
      // Release the SID as the request was never send
      sidMgr->ReleaseSID( req->streamid );
      delete msgHandler;
      return st;
    }
    return XRootDStatus();
  }

References ClientRequest::chkpoint, XrdCl::MessageSendParams::chunkedResponse, XrdCl::MessageSendParams::chunkList, XrdCl::MessageSendParams::crc32cDigests, XrdCl::Log::Dump(), XrdCl::Log::Error(), XrdCl::errUninitialized, XrdCl::MessageSendParams::expires, XrdCl::MessageSendParams::followRedirects, XrdCl::Buffer::GetBuffer(), XrdCl::URL::GetHostId(), XrdCl::DefaultEnv::GetLog(), XrdCl::Message::GetObfuscatedDescription(), XrdCl::DefaultEnv::GetPostMaster(), ClientRequest::header, XrdCl::MessageSendParams::hostList, XrdCl::SIDMgrPool::Instance(), XrdCl::Status::IsOK(), XrdCl::URL::IsValid(), XrdCl::MessageSendParams::kbuff, kXR_chkpoint, kXR_ckpXeq, XrdCl::MessageSendParams::loadBalancer, XrdCl::XRootDTransport::MarshallRequest(), ClientChkPointRequest::opcode, XrdCl::MessageSendParams::redirectLimit, ClientRequestHdr::requestid, XrdCl::PostMaster::Send(), XrdCl::XRootDMsgHandler::SetChunkList(), XrdCl::XRootDMsgHandler::SetCrc32cDigests(), XrdCl::XRootDMsgHandler::SetExpiration(), XrdCl::XRootDMsgHandler::SetHostList(), XrdCl::XRootDMsgHandler::SetKernelBuffer(), XrdCl::XRootDMsgHandler::SetLoadBalancer(), XrdCl::XRootDMsgHandler::SetOksofarAsAnswer(), XrdCl::XRootDMsgHandler::SetRedirectAsAnswer(), XrdCl::XRootDMsgHandler::SetRedirectCounter(), XrdCl::XRootDMsgHandler::SetStateful(), XrdCl::MessageSendParams::stateful, XrdCl::stError, ClientRequestHdr::streamid, XrdCl::Status::ToString(), XrdCl::XRootDTransport::UnMarshallRequest(), XrdCl::HostInfo::url, and XrdCl::XRootDMsg.

Referenced by XrdCl::FileSystemData::Send().

Here is the call graph for this function:

Here is the caller graph for this function:

WaitForResponse()

template<class Type>

XrdCl::XRootDStatus XrdCl::MessageUtils::WaitForResponse ( SyncResponseHandler * handler, Type *& response )

inlinestatic

Wait for the response.

Definition at line 168 of file XrdClMessageUtils.hh.

      {
        handler->WaitForResponse();
 
        AnyObject    *resp   = handler->GetResponse();
        XRootDStatus *status = handler->GetStatus();
        XRootDStatus ret( *status );
        delete status;
 
        if( ret.IsOK() )
        {
          if( !resp )
            return XRootDStatus( stError, errInternal );
          resp->Get( response );
          resp->Set( (int *)0 );
          delete resp;
 
          if( !response )
            return XRootDStatus( stError, errInternal );
        }
 
        return ret;
      }

References XrdCl::errInternal, XrdCl::AnyObject::Get(), XrdCl::SyncResponseHandler::GetResponse(), XrdCl::SyncResponseHandler::GetStatus(), XrdCl::Status::IsOK(), XrdCl::AnyObject::Set(), XrdCl::stError, and XrdCl::SyncResponseHandler::WaitForResponse().

Referenced by XrdCl::FileSystem::DeepLocate(), XrdCl::File::DelXAttr(), XrdCl::FileSystem::DelXAttr(), XrdCl::FileSystem::DirList(), XrdCl::File::Fcntl(), XrdCl::File::Fcntl(), XrdCl::File::GetXAttr(), XrdCl::FileSystem::GetXAttr(), XrdCl::File::ListXAttr(), XrdCl::FileSystem::ListXAttr(), XrdCl::FileSystem::Locate(), XrdCl::File::PgRead(), XrdCl::FileSystem::Prepare(), XrdCl::FileSystem::Protocol(), XrdCl::FileSystem::Query(), XrdCl::File::Read(), XrdCl::File::ReadV(), XrdCl::FileSystem::SendCache(), XrdCl::FileSystem::SendInfo(), XrdCl::File::SetXAttr(), XrdCl::FileSystem::SetXAttr(), XrdCl::File::Stat(), XrdCl::FileSystem::Stat(), XrdCl::FileSystem::StatVFS(), XrdCl::File::VectorRead(), and XrdCl::File::Visa().

Here is the call graph for this function:

Here is the caller graph for this function:

WaitForStatus()

XRootDStatus XrdCl::MessageUtils::WaitForStatus ( SyncResponseHandler * handler )

inlinestatic

Wait and return the status of the query.

Definition at line 155 of file XrdClMessageUtils.hh.

      {
        handler->WaitForResponse();
        XRootDStatus *status = handler->GetStatus();
        XRootDStatus ret( *status );
        delete status;
        return ret;
      }

References XrdCl::SyncResponseHandler::GetStatus(), and XrdCl::SyncResponseHandler::WaitForResponse().

Referenced by XrdCl::FileSystem::ChMod(), XrdCl::File::Clone(), XrdCl::File::Close(), XrdCl::FileSystem::MkDir(), XrdCl::FileSystem::Mv(), XrdCl::File::Open(), XrdCl::File::OpenUsingTemplate(), XrdCl::File::PgWrite(), XrdCl::FileSystem::Ping(), XrdCl::RedirectorRegistry::RegisterAndWait(), XrdCl::FileSystem::Rm(), XrdCl::FileSystem::RmDir(), XrdCl::File::Sync(), XrdCl::File::Truncate(), XrdCl::FileSystem::Truncate(), XrdCl::File::VectorWrite(), XrdCl::File::Write(), XrdCl::File::Write(), XrdCl::File::Write(), and XrdCl::File::WriteV().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• XrdClMessageUtils.hh
• XrdClMessageUtils.cc