XrdCmsManTree Class Reference

#include <XrdCmsManTree.hh>

Collaboration diagram for XrdCmsManTree:

Public Types
enum	connStat {   Aborted ,   Active ,   Connected ,   None ,   Pending ,   Waiting }

Public Member Functions
	XrdCmsManTree (int maxC)
	~XrdCmsManTree ()
void	Abort ()
int	Connect (int nID, XrdCmsNode *nP)
void	Disc (int nID)
int	Register ()
int	Trying (int nID, int Lvl)

Detailed Description

Definition at line 38 of file XrdCmsManTree.hh.

Member Enumeration Documentation

connStat

enum XrdCmsManTree::connStat

Enumerator
Aborted
Active
Connected
None
Pending
Waiting

Definition at line 52 of file XrdCmsManTree.hh.

{Aborted, Active, Connected, None, Pending, Waiting};

Constructor & Destructor Documentation

XrdCmsManTree()

XrdCmsManTree::XrdCmsManTree

(

int

maxC

)

Definition at line 45 of file XrdCmsManTree.cc.

                                     : maxTMI(0),  numConn(0), maxConn(maxC),
                                         atRoot(0), conLevel(0), conNID(-1),
                                         numWaiting(0), myStatus(Active)
{
    snprintf(buff, sizeof(buff), "%d", maxC);
}

~XrdCmsManTree()

XrdCmsManTree::~XrdCmsManTree ( )

inline

Definition at line 55 of file XrdCmsManTree.hh.

{};

Member Function Documentation

Abort()

void XrdCmsManTree::Abort

(

)

Definition at line 56 of file XrdCmsManTree.cc.

{
   XrdSysMutexHelper Monitor(myMutex);
 
// An abort may be issued to make sure no one is waiting to participate in
// tree construction. It's usually issued when the manager object has been
// permanently redirected.
//
   if (myStatus != Aborted && numWaiting)
      {for (int i = 0; i < maxTMI; i++)
           if (tmInfo[i].Status == Waiting) {tmInfo[i].Level = 0; Redrive(i);}
      }
 
// Indicate we have aborted
//
   myStatus = Aborted;
}

References Aborted, and Waiting.

Referenced by XrdCmsManager::Rerun().

Here is the caller graph for this function:

Connect()

int XrdCmsManTree::Connect	(	int	nID,
		XrdCmsNode *	nP
	)

Definition at line 78 of file XrdCmsManTree.cc.

{
   static CmsDiscRequest discRequest = {{0, kYR_disc, 0, 0}};
   XrdSysMutexHelper Monitor(myMutex);
   char mybuff[16];
   int i;
 
// Rule 0: If we aborted tell the client to just stop doing this
//
   if (myStatus == Aborted) return 0;
 
// Rule 1: If we are already connected, thell the caller to disband the
//         connection as we must have a connection to an interior node.
//
   if (myStatus == Connected) return 0;
   numConn++;
   tmInfo[nID].nodeP = nP;
 
// Rule 2: If we connected to a root node then consider ourselves connected
//         only if all connections are to the root.
//
   if (tmInfo[nID].Level == 0)
      {if (numConn == maxConn)
          {myStatus = Connected; conLevel = 0; atRoot = 1;
           Say.Emsg("ManTree", "Now connected to", buff, "root node(s)");
          }
       tmInfo[nID].Status = Connected;
       return 1;
      }
 
// Rule 3: We connected to an interior node. Disband all other existing
//         connections (these should only be to root nodes) and consider 
//         ourselves connected.
//
   for (i = 0; i < maxTMI; i++)
       if (i != nID && tmInfo[i].Status == Connected)
          {tmInfo[i].nodeP->Send((char *)&discRequest, sizeof(discRequest));
           tmInfo[i].Status = Pending;
          }
   myStatus = Connected;
   conLevel = tmInfo[nID].Level;
   conNID   = nID;
   atRoot   = 0;
 
// Document our connection configuration
//
   snprintf(mybuff, sizeof(mybuff), "%d", conLevel);
   Say.Emsg("ManTree", "Now connected to supervisor at level", mybuff);
   return 1;
}

References Aborted, Connected, XrdSysError::Emsg(), XrdCms::kYR_disc, Pending, and XrdCms::Say.

Here is the call graph for this function:

Disc()

void XrdCmsManTree::Disc

(

int

nID

)

Definition at line 133 of file XrdCmsManTree.cc.

{
 
// A connected caller has lost it's connection.
//
   myMutex.Lock();
   if (tmInfo[nID].Status == Connected || tmInfo[nID].Status == Pending)
      numConn--;
   tmInfo[nID].Status = Active;
   if (atRoot || (conLevel && conNID == nID)) myStatus = Active;
   tmInfo[nID].nodeP = 0;
   myMutex.UnLock();
}

References Active, Connected, XrdSysMutex::Lock(), Pending, and XrdSysMutex::UnLock().

Here is the call graph for this function:

Register()

int XrdCmsManTree::Register

(

)

Definition at line 151 of file XrdCmsManTree.cc.

{
   int nID;
 
// Add this server to the tree table. Register is called only once and there
// can be no more than MTMax connections to a manager. Hence, we dispense with
// error checking (how optimistic :-)
//
   myMutex.Lock();
   tmInfo[maxTMI].Status= Active;
   nID = maxTMI; maxTMI++;
   myMutex.UnLock();
   return nID;
}

References Active, XrdSysMutex::Lock(), and XrdSysMutex::UnLock().

Here is the call graph for this function:

Trying()

int XrdCmsManTree::Trying	(	int	nID,
		int	Lvl
	)

Definition at line 178 of file XrdCmsManTree.cc.

{
   int i;
 
// Set the current status of the connection
//
   myMutex.Lock();
   tmInfo[nID].Level  = lvl;
 
// Rule 0: If we aborted tell the client to just stop doing this
//
   if (myStatus == Aborted) return -1;
 
// Rule 1: If we are already connected at level >0 then the caller must wait
//
   if (myStatus == Connected && conLevel > 0) 
      {Pause(nID);
       return (lvl == tmInfo[nID].Level);
      }
 
// Rule 2: If the caller is trying level 0 then any waiting threads must be
//         allowed to continue but forced to level 0. This allows us to discover 
//         all the supervisors connected to the root.
//
   if (!lvl)
      {if (numWaiting)
          {for (i = 0; i < maxTMI; i++)
               if (i != nID && tmInfo[i].Status == Waiting)
                  {tmInfo[i].Level = 0; Redrive(i);}
          }
       myMutex.UnLock();
       return 1;
      }
 
// Rule 3: If the caller is trying at a non-zero level (interior node) and
//         someone else is trying at a non-zero level, then the caller must
//         wait.
//
   for (i = 0; i < maxTMI; i++)
        if (i != nID && tmInfo[i].Status == Active && tmInfo[i].Level) break;
   if (i < maxTMI) Pause(nID);
      else myMutex.UnLock();
 
// The caller may continue. Indicate whether the caller must restart at the
// root node. If the caller may continue trying to connect to an interior
// node then it's the only thread trying to do so.
//
   return (lvl == tmInfo[nID].Level);
}

References Aborted, Active, Connected, XrdSysMutex::Lock(), XrdSysMutex::UnLock(), and Waiting.

Here is the call graph for this function:

---

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

• XrdCmsManTree.hh
• XrdCmsManTree.cc