XrdClientConn.hh

Go to the documentation of this file.

#ifndef XRD_CONN_H
#define XRD_CONN_H
/******************************************************************************/
/*                                                                            */
/*                    X r d C l i e n t C o n n . h h                         */
/*                                                                            */
/* Author: Fabrizio Furano (INFN Padova, 2004)                                */
/* Adapted from TXNetFile (root.cern.ch) originally done by                   */
/*  Alvise Dorigo, Fabrizio Furano                                            */
/*          INFN Padova, 2003                                                 */
/*                                                                            */
/* 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 Lesser General Public       */
/* License for more details.                                                  */
/*                                                                            */
/* You should have received a copy of the GNU Lesser General Public License   */
/* along with XRootD in a file called COPYING.LESSER (LGPL license) and file  */
/* COPYING (GPL license).  If not, see <http://www.gnu.org/licenses/>.        */
/*                                                                            */
/* The copyright holder's institutional names and contributor's names may not */
/* be used to endorse or promote products derived from this software without  */
/* specific prior written permission of the institution or contributor.       */
/******************************************************************************/

//                                                                      //
// High level handler of connections to xrootd.                         //
//                                                                      //

#include "XrdClient/XrdClientConst.hh"

#include "time.h"
#include "XrdClient/XrdClientConnMgr.hh"
#include "XrdClient/XrdClientMessage.hh"
#include "XrdClient/XrdClientUrlInfo.hh"
#include "XrdClient/XrdClientReadCache.hh"
#include "XrdOuc/XrdOucHash.hh"
#include "XrdSys/XrdSysPthread.hh"

#define ConnectionManager XrdClientConn::GetConnectionMgr()

class XrdClientAbs;
class XrdSecProtocol;

class XrdClientConn {

public:

    enum ESrvErrorHandlerRetval {
        kSEHRReturnMsgToCaller   = 0,
        kSEHRBreakLoop           = 1,
        kSEHRContinue            = 2,
        kSEHRReturnNoMsgToCaller = 3,
        kSEHRRedirLimitReached   = 4
    };
    enum EThreeStateReadHandler {
        kTSRHReturnMex     = 0,
        kTSRHReturnNullMex = 1,
        kTSRHContinue      = 2
    };

    // To keep info about an open session
    struct                     SessionIDInfo {
        char id[16];
    };

    int                        fLastDataBytesRecv;
    int                        fLastDataBytesSent;
    XErrorCode                 fOpenError;      

    XrdOucString               fRedirOpaque;        // Opaque info returned by the server when

    // redirecting. To be used in the next opens
    XrdClientConn();
    virtual ~XrdClientConn();

    inline bool                CacheWillFit(long long bytes) {
        if (!fMainReadCache)
            return FALSE;
        return fMainReadCache->WillFit(bytes);
    }

    bool                       CheckHostDomain(XrdOucString hostToCheck);
    short                      Connect(XrdClientUrlInfo Host2Conn,
                                       XrdClientAbsUnsolMsgHandler *unsolhandler);
    void                       Disconnect(bool ForcePhysicalDisc);
    virtual bool               GetAccessToSrv();
    XReqErrorType              GoBackToRedirector();

    XrdOucString               GetClientHostDomain() { return fgClientHostDomain; }


    static XrdClientPhyConnection     *GetPhyConn(int LogConnID);


    // --------- Cache related stuff

    long                       GetDataFromCache(const void *buffer,
                                                long long begin_offs,
                                                long long end_offs,
                                                bool PerfCalc,
                                                XrdClientIntvList &missingblks,
                                                long &outstandingblks );

    bool                       SubmitDataToCache(XrdClientMessage *xmsg,
                                                 long long begin_offs,
                                                 long long end_offs);

    bool                       SubmitRawDataToCache(const void *buffer,
                                                 long long begin_offs,
                                                 long long end_offs);

    void                       SubmitPlaceholderToCache(long long begin_offs,
                                                        long long end_offs) {
        if (fMainReadCache)
            fMainReadCache->PutPlaceholder(begin_offs, end_offs);
    }

  
    void                       RemoveAllDataFromCache(bool keepwriteblocks=true) {
        if (fMainReadCache)
            fMainReadCache->RemoveItems(keepwriteblocks);
    }

    void                       RemoveDataFromCache(long long begin_offs,
                                                   long long end_offs, bool remove_overlapped = false) {
        if (fMainReadCache)
          fMainReadCache->RemoveItems(begin_offs, end_offs, remove_overlapped);
    }

    void                       RemovePlaceholdersFromCache() {
        if (fMainReadCache)
            fMainReadCache->RemovePlaceholders();
    }

    void                       PrintCache() {
        if (fMainReadCache)
            fMainReadCache->PrintCache();
    }


  bool                       GetCacheInfo(
                                          // The actual cache size
                                          int &size,

                                          // The number of bytes submitted since the beginning
                                          long long &bytessubmitted,

                                          // The number of bytes found in the cache (estimate)
                                          long long &byteshit,

                                          // The number of reads which did not find their data
                                          // (estimate)
                                          long long &misscount,

                                          // miss/totalreads ratio (estimate)
                                          float &missrate,

                                          // number of read requests towards the cache
                                          long long &readreqcnt,

                                          // ratio between bytes found / bytes submitted
                                          float &bytesusefulness
                                          ) {
      if (!fMainReadCache) return false;

      fMainReadCache->GetInfo(size,
                              bytessubmitted,
                              byteshit,
                              misscount,
                              missrate,
                              readreqcnt,
                              bytesusefulness);
      return true;
    }  
                                          

    void                       SetCacheSize(int CacheSize) {
        if (!fMainReadCache && CacheSize)
          fMainReadCache = new XrdClientReadCache();

        if (fMainReadCache)
           fMainReadCache->SetSize(CacheSize);
    }

    void                       SetCacheRmPolicy(int RmPolicy) {
        if (fMainReadCache)
           fMainReadCache->SetBlkRemovalPolicy(RmPolicy);
    }

    void                       UnPinCacheBlk(long long begin_offs, long long end_offs) {
        fMainReadCache->UnPinCacheBlk(begin_offs, end_offs);
        // Also use this to signal the possibility to proceed for a hard checkpoint
        fWriteWaitAck->Broadcast();
    }


    // -------------------


    int                        GetLogConnID() const { return fLogConnID; }

    ERemoteServerType          GetServerType() const { return fServerType; }

    kXR_unt16                  GetStreamID() const { return fPrimaryStreamid; }

    inline XrdClientUrlInfo    *GetLBSUrl() { return fLBSUrl; }
    inline XrdClientUrlInfo    *GetMetaUrl() { return fMetaUrl; }
    inline XrdClientUrlInfo    GetCurrentUrl() { return fUrl; }
    inline XrdClientUrlInfo    GetRedirUrl() { return fREQUrl; }

    XErrorCode                 GetOpenError() const { return fOpenError; }
    virtual XReqErrorType      GoToAnotherServer(XrdClientUrlInfo &newdest);
    virtual XReqErrorType      GoToMetaManager();
    bool                       IsConnected() const { return fConnected; }
    bool                       IsPhyConnConnected();

    struct ServerResponseHeader
                               LastServerResp;

    struct ServerResponseBody_Error
                               LastServerError;

    void                       ClearLastServerError() {
                                   memset(&LastServerError, 0, sizeof(LastServerError));
                                   LastServerError.errnum = kXR_noErrorYet;
                               }

    UnsolRespProcResult        ProcessAsynResp(XrdClientMessage *unsolmsg);

    virtual bool               SendGenCommand(ClientRequest *req, 
                                              const void *reqMoreData,       
                                              void **answMoreDataAllocated,
                                              void *answMoreData, bool HasToAlloc,
                                              char *CmdName, int substreamid = 0);

    int                        GetOpenSockFD() const { return fOpenSockFD; }

    void                       SetClientHostDomain(const char *src) { fgClientHostDomain = src; }
    void                       SetConnected(bool conn) { fConnected = conn; }

    void                       SetOpenError(XErrorCode err) { fOpenError = err; }

    // Gets a parallel stream id to use to set the return path for a re
    int                        GetParallelStreamToUse(int reqsperstream);
    int                        GetParallelStreamCount();     // Returns the total number of connected streams

    void                       SetRedirHandler(XrdClientAbs *rh) { fRedirHandler = rh; }

    void                       SetRequestedDestHost(char *newh, kXR_int32 port) {
        fREQUrl = fUrl;
        fREQUrl.Host = newh;
        fREQUrl.Port = port;
        fREQUrl.SetAddrFromHost();
    }

    // Puts this instance in pause state for wsec seconds.
    // A value <= 0 revokes immediately the pause state
    void                       SetREQPauseState(kXR_int32 wsec) {
        // Lock mutex
        fREQWait->Lock();

        if (wsec > 0)
            fREQWaitTimeLimit = time(0) + wsec;
        else {
            fREQWaitTimeLimit = 0;
            fREQWait->Broadcast();
        }

        // UnLock mutex
        fREQWait->UnLock();
    }

    // Puts this instance in connect-pause state for wsec seconds.
    // Any future connection attempt will not happen before wsec
    //  and the first one will be towards the given host
    void                       SetREQDelayedConnectState(kXR_int32 wsec) {
        // Lock mutex
        fREQConnectWait->Lock();

        if (wsec > 0)
            fREQConnectWaitTimeLimit = time(0) + wsec;
        else {
            fREQConnectWaitTimeLimit = 0;
            fREQConnectWait->Broadcast();
        }

        // UnLock mutex
        fREQConnectWait->UnLock();
    }

    void                       SetSID(kXR_char *sid);
    inline void                SetUrl(XrdClientUrlInfo thisUrl) { fUrl = thisUrl; }

    // Sends the request to the server, through logconn with ID LogConnID
    // The request is sent with a streamid 'child' of the current one, then marked as pending
    // Its answer will be caught asynchronously
    XReqErrorType              WriteToServer_Async(ClientRequest *req, 
                                                   const void* reqMoreData,
                                                   int substreamid = 0);

    static XrdClientConnectionMgr *GetConnectionMgr()
    { return fgConnectionMgr;} //Instance of the conn manager

    static void DelSessionIDRepo()         {fSessionIDRMutex.Lock();
                                            fSessionIDRepo.Purge();
                                            fSessionIDRMutex.UnLock();
                                           }

    void GetSessionID(SessionIDInfo &sess) {sess = mySessionID;}

    long                       GetServerProtocol() { return fServerProto; }

    short                      GetMaxRedirCnt() const { return fMaxGlobalRedirCnt; }
    void                       SetMaxRedirCnt(short mx) {fMaxGlobalRedirCnt = mx; }
    short                      GetRedirCnt() const { return fGlobalRedirCnt; }

    bool                       DoWriteSoftCheckPoint();
    bool                       DoWriteHardCheckPoint();
    void                       UnPinCacheBlk();


    // To give a max number of seconds for an operation to complete, no matter what happens inside
    // e.g. redirections, sleeps, failed connection attempts etc.
    void                       SetOpTimeLimit(int delta_secs);
    bool                       IsOpTimeLimitElapsed(time_t timenow);


protected:
    void                       SetLogConnID(int cid) { fLogConnID = cid; }
    void                       SetStreamID(kXR_unt16 sid) { fPrimaryStreamid = sid; }



    // The handler which first tried to connect somewhere
    XrdClientAbsUnsolMsgHandler *fUnsolMsgHandler;

    XrdClientUrlInfo           fUrl;                // The current URL
    XrdClientUrlInfo           *fLBSUrl;            // Needed to save the load balancer url
    XrdClientUrlInfo           fREQUrl;             // For explicitly requested redirs

    short                      fGlobalRedirCnt;    // Number of redirections

private:

    static XrdOucString        fgClientHostDomain; // Save the client's domain name
    bool                       fConnected;
    bool                       fGettingAccessToSrv; // To avoid recursion in desperate situations
    time_t                     fGlobalRedirLastUpdateTimestamp; // Timestamp of last redirection

    int                        fLogConnID;        // Logical connection ID used
    kXR_unt16                  fPrimaryStreamid;  // Streamid used for normal communication
    // NB it's a copy of the one contained in
    // the logconn

    short                      fMaxGlobalRedirCnt;
    XrdClientReadCache         *fMainReadCache;

    // The time limit for a transaction
    time_t                     fOpTimeLimit;

    XrdClientAbs               *fRedirHandler;      // Pointer to a class inheriting from
    // XrdClientAbs providing methods
    // to handle a redir at higher level

    XrdOucString               fRedirInternalToken; // Token returned by the server when
    // redirecting. To be used in the next logins

    XrdSysCondVar              *fREQWaitResp;           // For explicitly requested delayed async responses
    ServerResponseBody_Attn_asynresp *
                               fREQWaitRespData;        // For explicitly requested delayed async responses

    time_t                     fREQWaitTimeLimit;   // For explicitly requested pause state
    XrdSysCondVar              *fREQWait;           // For explicitly requested pause state
    time_t                     fREQConnectWaitTimeLimit;   // For explicitly requested delayed reconnect
    XrdSysCondVar              *fREQConnectWait;           // For explicitly requested delayed reconnect

    long                       fServerProto;        // The server protocol
    ERemoteServerType          fServerType;         // Server type as returned by doHandShake() 
    SessionIDInfo              mySessionID;         // Login session ID


    static XrdSysMutex         fSessionIDRMutex;    // Mutex for the Repo
    static XrdOucHash<SessionIDInfo>
    fSessionIDRepo;      // The repository of session IDs, shared.
    // Association between
    // <hostname>:<port>.<user> and a SessionIDInfo struct

    int                        fOpenSockFD;         // Descriptor of the underlying socket
    static XrdClientConnectionMgr *fgConnectionMgr; //Instance of the Connection Manager

    XrdSysCondVar              *fWriteWaitAck;
    XrdClientVector<ClientRequest> fWriteReqsToRetry; // To store the write reqs to retry in case of a disconnection

    bool                       CheckErrorStatus(XrdClientMessage *, short &, char *);
    void                       CheckPort(int &port);
    void                       CheckREQPauseState();
    void                       CheckREQConnectWaitState();
    bool                       CheckResp(struct ServerResponseHeader *resp, const char *method);
    XrdClientMessage           *ClientServerCmd(ClientRequest *req,
                                                const void *reqMoreData,
                                                void **answMoreDataAllocated,
                                                void *answMoreData,
                                                bool HasToAlloc,
                                                int substreamid = 0);
    XrdSecProtocol            *DoAuthentication(char *plist, int plsiz);

    ERemoteServerType          DoHandShake(short log);

    bool                       DoLogin();
    bool                       DomainMatcher(XrdOucString dom, XrdOucString domlist);

    XrdOucString               GetDomainToMatch(XrdOucString hostname);

    ESrvErrorHandlerRetval     HandleServerError(XReqErrorType &, XrdClientMessage *,
                                                 ClientRequest *);
    bool                       MatchStreamid(struct ServerResponseHeader *ServerResponse);

    // Sends a close request, without waiting for an answer
    // useful (?) to be sent just before closing a badly working stream
    bool                       PanicClose();

    XrdOucString               ParseDomainFromHostname(XrdOucString hostname);

    XrdClientMessage           *ReadPartialAnswer(XReqErrorType &, size_t &, 
                                                  ClientRequest *, bool, void**,
                                                  EThreeStateReadHandler &);

//  void                       ClearSessionID();

    XReqErrorType              WriteToServer(ClientRequest *req, 
                                             const void* reqMoreData,
                                             short LogConnID,
                                             int substreamid = 0);

    bool                       WaitResp(int secsmax);

    XrdClientUrlInfo           *fMetaUrl;           // Meta manager url
    bool                        fLBSIsMeta;         // Is current redirector a meta manager?

public:
    XrdOucString               fRedirCGI;           // Same as fRedirOpaque but persistent

};
#endif