XrdClPostMasterInterfaces.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_POST_MASTER_INTERFACES_HH__
#define __XRD_CL_POST_MASTER_INTERFACES_HH__
 
#include "XrdCl/XrdClXRootDResponses.hh"
 
#include <cstdint>
#include <ctime>
#include <memory>
 
#include "XrdCl/XrdClStatus.hh"
#include "XrdCl/XrdClAnyObject.hh"
#include "XrdCl/XrdClURL.hh"
 
class XrdNetAddr;
 
namespace XrdCl
{
  class Channel;
  class Message;
  class URL;
  class Socket;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class MsgHandler
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum Action
      {
        None          = 0x0000,
        Nop           = 0x0001,    
        Ignore        = 0x0002,    
        RemoveHandler = 0x0004,    
        Raw           = 0x0008,    
        NoProcess     = 0x0010,    
        Corrupted     = 0x0020,    
        More          = 0x0040     
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum StreamEvent
      {
        Ready      = 1, 
        Broken     = 2, 
        Timeout    = 3, 
        FatalError = 4  
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
 
      virtual ~MsgHandler() {}
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual uint16_t Examine( std::shared_ptr<Message> &msg ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual uint16_t InspectStatusRsp() = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual uint16_t GetSid() const = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void Process() {};
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual XRootDStatus ReadMessageBody( Message  *msg,
                                            Socket   *socket,
                                            uint32_t &bytesRead )
      {
        (void)msg; (void)socket; (void)bytesRead;
        return Status( stOK, suDone );
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual uint8_t OnStreamEvent( StreamEvent   event,
                                     XRootDStatus  status )
      {
        (void)event; (void)status;
        return 0;
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void OnStatusReady( const Message *message,
                                  XRootDStatus   status ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void OnReadyToSend( Message *msg )
      {
        (void)msg;
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual bool IsRaw() const { return false; }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual XRootDStatus WriteMessageBody( Socket   *socket,
                                             uint32_t &bytesWritten )
      {
        (void)socket; (void)bytesWritten;
        return Status();
      }
 
      virtual time_t GetExpiration() = 0;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class ChannelEventHandler
  {
    public:
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum ChannelEvent
      {
        StreamReady  = 1, 
        StreamBroken = 2, 
        FatalError   = 4  
      };
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual ~ChannelEventHandler() {};
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual bool OnChannelEvent( ChannelEvent event,
                                   Status       status ) = 0;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
 
  struct HandShakeData
  {
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    HandShakeData( const URL *addr, uint16_t subStream ):
      step(0), out(0), in(0), url(addr), subStreamId( subStream ),
      startTime( time(0) ), serverAddr(0)
    {}
    uint16_t     step;           
    Message     *out;            
    Message     *in;             
    const URL   *url;            
    uint16_t     subStreamId;    
    time_t       startTime;      
    const
    XrdNetAddr  *serverAddr;     
    std::string  clientName;     
    std::string  streamName;     
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  struct PathID
  {
    PathID( uint16_t u = 0, uint16_t d = 0 ): up(u), down(d) {}
    uint16_t up;
    uint16_t down;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  struct TransportQuery
  {
    static const uint16_t Name    = 1; 
    static const uint16_t Auth    = 2; 
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  struct XRootDQuery
  {
    static const uint16_t ServerFlags     = 1002; 
    static const uint16_t ProtocolVersion = 1003; 
    static const uint16_t IsEncrypted     = 1004; 
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  struct StreamQuery
  {
      static const uint16_t IpAddr   = 2001;
      static const uint16_t IpStack  = 2002;
      static const uint16_t HostName = 2003;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class TransportHandler
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      enum StreamAction
      {
        NoAction     = 0x0000, 
        DigestMsg    = 0x0001, 
        AbortStream  = 0x0002, 
        CloseStream  = 0x0004, 
        ResumeStream = 0x0008, 
        HoldStream   = 0x0010, 
        RequestClose = 0x0020  
      };
 
 
      virtual ~TransportHandler() {}
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual XRootDStatus GetHeader( Message &message, Socket *socket ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual XRootDStatus GetBody( Message &message, Socket *socket ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual XRootDStatus GetMore( Message &message, Socket *socket ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void InitializeChannel( const URL  &url,
                                      AnyObject  &channelData ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void FinalizeChannel( AnyObject &channelData ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual XRootDStatus HandShake( HandShakeData *handShakeData,
                                      AnyObject     &channelData ) = 0;
 
      //------------------------------------------------------------------------
      // @return true if handshake has been done and stream is connected,
      //         false otherwise
      //------------------------------------------------------------------------
      virtual bool HandShakeDone( HandShakeData *handShakeData,
                                  AnyObject     &channelData ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual bool IsStreamTTLElapsed( time_t     inactiveTime,
                                       AnyObject &channelData ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual Status IsStreamBroken( time_t     inactiveTime,
                                     AnyObject &channelData ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual PathID Multiplex( Message   *msg,
                                AnyObject &channelData,
                                PathID    *hint = 0 ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual PathID MultiplexSubStream( Message   *msg,
                                         AnyObject &channelData,
                                         PathID    *hint = 0 ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual uint16_t SubStreamNumber( AnyObject &channelData ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void Disconnect( AnyObject &channelData,
                               uint16_t   subStreamId ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual Status Query( uint16_t   query,
                            AnyObject &result,
                            AnyObject &channelData ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual uint32_t MessageReceived( Message   &msg,
                                        uint16_t   subStream,
                                        AnyObject &channelData ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void MessageSent( Message   *msg,
                                uint16_t   subStream,
                                uint32_t   bytesSent,
                                AnyObject &channelData ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void WaitBeforeExit() = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual bool NeedEncryption( HandShakeData  *handShakeData,
                                  AnyObject      &channelData ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual Status GetSignature( Message *toSign, Message *&sign,
                                   AnyObject &channelData ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual void DecFileInstCnt( AnyObject &channelData ) = 0;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      virtual URL GetBindPreference( const URL  &url,
                                     AnyObject  &channelData ) = 0;
  };
}
 
#endif // __XRD_CL_POST_MASTER_INTERFACES_HH__