#include <XrdOfsEvs.hh>

Collaboration diagram for XrdOfsEvs:

Public Types
enum	Event { All = 0x7fffff00 , None = 0x00000000 , Chmod = 0x00000100 , Closer = 0x00000201 , Closew = 0x00000402 , Close = 0x00000600 , Create = 0x00000803 , Fwrite = 0x00001004 , Mkdir = 0x00002005 , Mv = 0x00004006 , Openr = 0x00008007 , Openw = 0x00010008 , Open = 0x00018000 , Rm = 0x00020009 , Rmdir = 0x0004000a , Trunc = 0x0008000b , nCount = 12 , Mask = 0X000000ff , enMask = 0x7fffff00 }

Public Member Functions
	XrdOfsEvs (Event theEvents, const char *Target, int minq=90, int maxq=10)

	~XrdOfsEvs ()

int	Enabled (Event theEvents)

int	maxLmsg ()

int	maxSmsg ()

void	Notify (Event eNum, XrdOfsEvsInfo &Info)

const char *	Prog ()

void	sendEvents (void)

int	Start (XrdSysError *eobj)

Static Public Member Functions
static int	Parse (XrdSysError &Eroute, Event eNum, char *mText)

Static Public Attributes
static const int	maxMsgSize = 2384

static const int	minMsgSize = 1360

Detailed Description

Definition at line 120 of file XrdOfsEvs.hh.

Member Enumeration Documentation

◆ Event

enum XrdOfsEvs::Event

Enumerator
All
None
Chmod
Closer
Closew
Close
Create
Fwrite
Mkdir
Mv
Openr
Openw
Open
Rm
Rmdir
Trunc
nCount
Mask
enMask

Definition at line 124 of file XrdOfsEvs.hh.

           {All    = 0x7fffff00, None   = 0x00000000,
            Chmod  = 0x00000100, Closer = 0x00000201,
            Closew = 0x00000402, Close  = 0x00000600,
            Create = 0x00000803, Fwrite = 0x00001004,
            Mkdir  = 0x00002005, Mv     = 0x00004006,
            Openr  = 0x00008007, Openw  = 0x00010008,
            Open   = 0x00018000, Rm     = 0x00020009,
            Rmdir  = 0x0004000a, Trunc  = 0x0008000b,
            nCount = 12,
            Mask   = 0X000000ff, enMask = 0x7fffff00
           };

Constructor & Destructor Documentation

◆ XrdOfsEvs()

XrdOfsEvs::XrdOfsEvs	(	Event	theEvents,
		const char *	Target,
		int	minq = 90,
		int	maxq = 10 )

Definition at line 118 of file XrdOfsEvs.cc.

{
 
// Set common variables
//
   enEvents = static_cast<Event>(theEvents & enMask);
   endIT = 0;
   theTarget = strdup(Target);
   eDest = 0; 
   theProg = 0;
   maxMin = minq; maxMax = maxq;
   msgFirst = msgLast = msgFreeMax = msgFreeMin = 0;
   numMax = numMin = 0; 
   tid = 0;
   msgFD = -1;
 
// Initialize all static format entries that have not been initialized yet.
// Note that format may be specified prior to this object being created!
//
// <tid> chmod  <mode> <path>
//
   MsgFmt[Chmod  & Mask].Def(XrdOfsEvsFormat::cvtMode, "%s chmod %s %s\n",
                             XrdOfsEvsInfo::evTID,
                             XrdOfsEvsInfo::evFMODE, XrdOfsEvsInfo::evLFN1, -1);
// <tid> closer <path>
//
   MsgFmt[Closer & Mask].Def(XrdOfsEvsFormat::Null,    "%s closer %s\n",
                             XrdOfsEvsInfo::evTID,   XrdOfsEvsInfo::evLFN1, -1);
                                              
// <tid> closew <path>
//
   MsgFmt[Closew & Mask].Def(XrdOfsEvsFormat::Null,    "%s closew %s\n",
                             XrdOfsEvsInfo::evTID,   XrdOfsEvsInfo::evLFN1, -1);
                                              
// <tid> create <mode> <path>
//
   MsgFmt[Create & Mask].Def(XrdOfsEvsFormat::cvtMode, "%s create %s %s\n",
                             XrdOfsEvsInfo::evTID,
                             XrdOfsEvsInfo::evFMODE, XrdOfsEvsInfo::evLFN1, -1);
// <tid> mkdir  <mode> <path>
//
   MsgFmt[Mkdir  & Mask].Def(XrdOfsEvsFormat::cvtMode, "%s mkdir %s %s\n",
                             XrdOfsEvsInfo::evTID,
                             XrdOfsEvsInfo::evFMODE, XrdOfsEvsInfo::evLFN1, -1);
// <tid> mv     <path> <path>
//
   MsgFmt[Mv     & Mask].Def(XrdOfsEvsFormat::Null,    "%s mv %s %s\n",
                             XrdOfsEvsInfo::evTID,
                             XrdOfsEvsInfo::evLFN1,  XrdOfsEvsInfo::evLFN2, -1);
// <tid> openr  <path>
//
   MsgFmt[Openr  & Mask].Def(XrdOfsEvsFormat::Null,    "%s openr %s\n",
                             XrdOfsEvsInfo::evTID,   XrdOfsEvsInfo::evLFN1, -1);
                                              
// <tid> openw  <path>
//
   MsgFmt[Openw  & Mask].Def(XrdOfsEvsFormat::Null,    "%s openw %s\n",
                             XrdOfsEvsInfo::evTID,   XrdOfsEvsInfo::evLFN1, -1);
                                              
// <tid> rm     <path>
//
   MsgFmt[Rm     & Mask].Def(XrdOfsEvsFormat::Null,    "%s rm %s\n",
                             XrdOfsEvsInfo::evTID,   XrdOfsEvsInfo::evLFN1, -1);
                                              
// <tid> rmdir  <path>
//
   MsgFmt[Rmdir  & Mask].Def(XrdOfsEvsFormat::Null,    "%s rmdir %s\n",
                             XrdOfsEvsInfo::evTID,   XrdOfsEvsInfo::evLFN1, -1);
                                              
// <tid> trunc  <size>
//
   MsgFmt[Trunc  & Mask].Def(XrdOfsEvsFormat::cvtFSize,"%s trunc %s\n",
                             XrdOfsEvsInfo::evTID,   XrdOfsEvsInfo::evFSIZE,-1);
                                              
// <tid> fwrite <path>
//
   MsgFmt[Fwrite & Mask].Def(XrdOfsEvsFormat::Null,    "%s fwrite %s\n",
                             XrdOfsEvsInfo::evTID,   XrdOfsEvsInfo::evLFN1, -1);
}

References Chmod, Closer, Closew, Create, XrdOfsEvsFormat::cvtFSize, XrdOfsEvsFormat::cvtMode, enMask, XrdOfsEvsInfo::evFMODE, XrdOfsEvsInfo::evFSIZE, XrdOfsEvsInfo::evLFN1, XrdOfsEvsInfo::evLFN2, XrdOfsEvsInfo::evTID, Fwrite, Mask, Mkdir, Mv, XrdOfsEvsFormat::Null, Openr, Openw, Rm, Rmdir, and Trunc.

◆ ~XrdOfsEvs()

XrdOfsEvs::~XrdOfsEvs ( )

Definition at line 202 of file XrdOfsEvs.cc.

{
  XrdOfsEvsMsg *tp;
 
// Kill the notification thread. This may cause a msg block to be orphaned
// but, in practice, this object does not really get deleted after being 
// started. So, the problem is moot.
//
   endIT = 1;
   if (tid) XrdSysThread::Kill(tid);
 
// Release all queued message bocks
//
  qMut.Lock();
  while ((tp = msgFirst)) {msgFirst = tp->next; delete tp;}
  if (theTarget) free(theTarget);
  if (msgFD >= 0)close(msgFD);
  if (theProg)   delete theProg;
  qMut.UnLock();
 
// Release all free message blocks
//
  fMut.Lock();
  while ((tp = msgFreeMax)) {msgFreeMax = tp->next; delete tp;}
  while ((tp = msgFreeMin)) {msgFreeMin = tp->next; delete tp;}
  fMut.UnLock();
}

References close, XrdSysThread::Kill(), and XrdOfsEvsMsg::next.

Here is the call graph for this function:

Member Function Documentation

◆ Enabled()

int XrdOfsEvs::Enabled ( Event theEvents )

inline

Definition at line 139 of file XrdOfsEvs.hh.

139{return theEvents & enEvents;}

◆ maxLmsg()

int XrdOfsEvs::maxLmsg ( )

inline

Definition at line 142 of file XrdOfsEvs.hh.

142{return maxMax;}

◆ maxSmsg()

int XrdOfsEvs::maxSmsg ( )

inline

Definition at line 141 of file XrdOfsEvs.hh.

141{return maxMin;}

◆ Notify()

void XrdOfsEvs::Notify	(	Event	eNum,
		XrdOfsEvsInfo &	Info )

Definition at line 234 of file XrdOfsEvs.cc.

{
   static int warnings = 0;
   XrdOfsEvsFormat *fP;
   XrdOfsEvsMsg *tp;
   char modebuff[8], sizebuff[16];
   int eNum, isBig = (eID & Mv), msgSize = (isBig ? maxMsgSize : minMsgSize);
 
// Validate event number and set event name
//
   eNum = eID & Mask;
   if (eNum < 0 || eNum >= nCount) return;
 
// Check if we need to do any conversions
//
   fP = &MsgFmt[eNum];
   if (fP->Flags & XrdOfsEvsFormat::cvtMode)
      {sprintf(modebuff, "%o", static_cast<int>((Info.FMode() & S_IAMB)));
       Info.Set(XrdOfsEvsInfo::evFMODE, modebuff);
      } else Info.Set(XrdOfsEvsInfo::evFMODE, "$FMODE");
   if (fP->Flags & XrdOfsEvsFormat::cvtFSize)
      {sprintf(sizebuff, "%lld", Info.FSize());
       Info.Set(XrdOfsEvsInfo::evFSIZE, sizebuff);
      } else Info.Set(XrdOfsEvsInfo::evFSIZE, "$FSIZE");
 
// Get a message block
//
   if (!(tp = getMsg(isBig)))
      {if ((++warnings & 0xff) == 1)
         {eDest->Emsg("Notify", "Ran out of message objects;", eName(eNum),
                                "event notification not sent.");
         }
       return;
      }
 
// Format the message
//
   tp->tlen = fP->SNP(Info, tp->text, msgSize);
 
// Put the message on the queue and return
//
   tp->next = 0;
   qMut.Lock();
   if (msgLast) {msgLast->next = tp; msgLast = tp;}
      else msgFirst = msgLast = tp;
   qMut.UnLock();
   qSem.Post();
}

References XrdOfsEvsFormat::cvtFSize, XrdOfsEvsFormat::cvtMode, XrdOfsEvsInfo::evFMODE, XrdOfsEvsInfo::evFSIZE, XrdOfsEvsFormat::Flags, Mask, maxMsgSize, minMsgSize, Mv, nCount, XrdOfsEvsMsg::next, S_IAMB, XrdOfsEvsFormat::SNP(), XrdOfsEvsMsg::text, and XrdOfsEvsMsg::tlen.

Here is the call graph for this function:

◆ Parse()

int XrdOfsEvs::Parse	(	XrdSysError &	Eroute,
		XrdOfsEvs::Event	eNum,
		char *	mText )

static

Definition at line 287 of file XrdOfsEvs.cc.

{
    static struct valVar {const char              *vname;
                          XrdOfsEvsInfo::evArg     vnum;
                          XrdOfsEvsFormat::evFlags vopt;}
        Vars[] = {
        {"TID",     XrdOfsEvsInfo::evTID,   XrdOfsEvsFormat::Null},
        {"LFN",     XrdOfsEvsInfo::evLFN1,  XrdOfsEvsFormat::Null},
        {"LFN1",    XrdOfsEvsInfo::evLFN1,  XrdOfsEvsFormat::Null},
        {"CGI",     XrdOfsEvsInfo::evCGI1,  XrdOfsEvsFormat::Null},
        {"CGI1",    XrdOfsEvsInfo::evCGI1,  XrdOfsEvsFormat::Null},
        {"LFN2",    XrdOfsEvsInfo::evLFN2,  XrdOfsEvsFormat::Null},
        {"CGI2",    XrdOfsEvsInfo::evCGI2,  XrdOfsEvsFormat::Null},
        {"FMODE",   XrdOfsEvsInfo::evFMODE, XrdOfsEvsFormat::cvtMode},
        {"FSIZE",   XrdOfsEvsInfo::evFSIZE, XrdOfsEvsFormat::cvtFSize}
       };
   int numvars = sizeof(Vars)/sizeof(struct valVar);
   char parms[1024], *pP = parms;
   char *pE = parms+sizeof(parms)-((XrdOfsEvsInfo::evARGS*2)-8);
   char varbuff[16], *bVar, *eVar;
   int  i, j, aNum = 0, Args[XrdOfsEvsInfo::evARGS] = {0};
   XrdOfsEvsFormat::evFlags ArgOpts = XrdOfsEvsFormat::freeFmt;
 
// Parse the text
//
   parms[0] = '\0';
   while(*mText && pP < pE)
        {if (*mText == '\\' && *(mText+1) == '$')
            {*pP++ = '$'; mText += 2; continue;}
            else if (*mText != '$') {*pP++ = *mText++; continue;}
         bVar = mText+1;
              if (*mText == '{') {eVar = index(mText, '}'); j = 1;}
         else if (*mText == '[') {eVar = index(mText, ']'); j = 1;}
         else {eVar = bVar; while(isalpha(*eVar)) eVar++;   j = 0;}
         i = eVar - bVar;
         if (i < 1 || i >= (int)sizeof(varbuff))
            {Eroute.Emsg("Parse","Invalid notifymsg variable starting at",mText);
             return 1;
            }
         strncpy(varbuff, bVar, i); varbuff[i] = '\0';
         for (i = 0; i < numvars; i++)
             if (!strcmp(varbuff, Vars[i].vname)) break;
         if (i >= numvars)
            {Eroute.Emsg("Parse", "Unknown notifymsg variable -",varbuff);
             return 1;
            }
         if (aNum >= XrdOfsEvsInfo::evARGS)
            {Eroute.Say("Parse", "Too many notifymsg variables"); return 1;}
         strcpy(pP, "%s"); pP += 2;
         Args[aNum++] = Vars[i].vnum; 
         ArgOpts = static_cast<XrdOfsEvsFormat::evFlags>(ArgOpts|Vars[i].vopt);
         mText = eVar+j;
        }
 
// Check if we overran the buffer or didn't have any text
//
   if (pP >= pE)
      {Eroute.Emsg("Parse","notifymsg text too long");return 1;}
   if (!parms[0])
      {Eroute.Emsg("Parse","notifymsg text not specified");return 1;}
 
// Set the format
//
   strcpy(pP, "\n");
   eNum = static_cast<Event>(eNum & Mask);
   MsgFmt[eNum].Set(ArgOpts, strdup(parms), Args);
 
// All done
//
   return 0;
}

References XrdOfsEvsFormat::cvtFSize, XrdOfsEvsFormat::cvtMode, XrdSysError::Emsg(), XrdOfsEvsInfo::evARGS, XrdOfsEvsInfo::evCGI1, XrdOfsEvsInfo::evCGI2, XrdOfsEvsInfo::evFMODE, XrdOfsEvsInfo::evFSIZE, XrdOfsEvsInfo::evLFN1, XrdOfsEvsInfo::evLFN2, XrdOfsEvsInfo::evTID, XrdOfsEvsFormat::freeFmt, Mask, XrdOfsEvsFormat::Null, and XrdSysError::Say().

Here is the call graph for this function:

◆ Prog()

const char * XrdOfsEvs::Prog ( )

inline

Definition at line 148 of file XrdOfsEvs.hh.

148{return theTarget;}

◆ sendEvents()

void XrdOfsEvs::sendEvents ( void )

Definition at line 363 of file XrdOfsEvs.cc.

{
   XrdOfsEvsMsg *tp;
   const char *theData[2] = {0,0};
         int   theDlen[2] = {0,0};
 
// This is an endless loop that just gets things off the event queue and
// send them out. This allows us to only hang a simgle thread should the
// receiver get blocked, instead of the whole process.
//
   while(1)
        {qSem.Wait();
         qMut.Lock();
         if (endIT) break;
         if ((tp = msgFirst) && !(msgFirst = tp->next)) msgLast = 0;
         qMut.UnLock();
         if (tp) 
            {if (!theProg) Feed(tp->text, tp->tlen);
                else {theData[0] = tp->text; theDlen[0] = tp->tlen;
                      theProg->Feed(theData, theDlen);
                     }
             retMsg(tp);
            }
         }
   qMut.UnLock();
}

References XrdOfsEvsMsg::next, XrdOfsEvsMsg::text, and XrdOfsEvsMsg::tlen.

Referenced by XrdOfsEvsSend().

Here is the caller graph for this function:

◆ Start()

int XrdOfsEvs::Start ( XrdSysError * eobj )

Definition at line 394 of file XrdOfsEvs.cc.

{
   int rc;
 
// Set the error object pointer
//
   eDest = eobj;
 
// Check if we need to create a socket to a path
//
   if (*theTarget == '>')
      {XrdNetSocket *msgSock;
       if (!(msgSock = XrdNetSocket::Create(eobj,theTarget+1,0,0660,XRDNET_FIFO)))
          return -1;
       msgFD = msgSock->Detach();
       delete msgSock;
 
      } else {
 
      // Allocate a new program object if we don't have one
      //
         if (theProg) return 0;
         theProg = new XrdOucProg(eobj);
 
     // Setup the program
     //
        if (theProg->Setup(theTarget, eobj)) return -1;
        if ((rc = theProg->Start()))
           {eobj->Emsg("Evs", rc, "start event collector"); return -1;}
    }
 
// Now start a thread to get messages and send them to the collector
//
   if ((rc = XrdSysThread::Run(&tid, XrdOfsEvsSend, static_cast<void *>(this),
                          0, "Event notification sender")))
      {eobj->Emsg("Evs", rc, "create event notification thread");
       return -1;
      }
 
// All done
//
   return 0;
}

References XrdNetSocket::Create(), XrdNetSocket::Detach(), XrdSysError::Emsg(), XrdSysThread::Run(), XRDNET_FIFO, and XrdOfsEvsSend().

Here is the call graph for this function:

Member Data Documentation

◆ maxMsgSize

const int XrdOfsEvs::maxMsgSize = 2384

static

Definition at line 137 of file XrdOfsEvs.hh.

Referenced by Notify().

◆ minMsgSize

const int XrdOfsEvs::minMsgSize = 1360

static

Definition at line 136 of file XrdOfsEvs.hh.

Referenced by Notify().

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

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Detailed Description

Member Enumeration Documentation

◆ Event

Constructor & Destructor Documentation

◆ XrdOfsEvs()

◆ ~XrdOfsEvs()

Member Function Documentation

◆ Enabled()

◆ maxLmsg()

◆ maxSmsg()

◆ Notify()

◆ Parse()

◆ Prog()

◆ sendEvents()

◆ Start()

Member Data Documentation

◆ maxMsgSize

◆ minMsgSize