XrdXrootdPrepare Class Reference

#include <XrdXrootdPrepare.hh>

Inheritance diagram for XrdXrootdPrepare:

Collaboration diagram for XrdXrootdPrepare:

Public Member Functions
	XrdXrootdPrepare (XrdSysError *lp, XrdScheduler *sp, bool nomsg)
	~XrdXrootdPrepare ()
void	DoIt ()
Public Member Functions inherited from XrdJob
	XrdJob (const char *desc="")
virtual	~XrdJob ()

Static Public Member Functions
static int	Close (int fd)
static int	List (XrdXrootdPrepArgs &pargs, char *resp, int resplen)
static void	Log (XrdXrootdPrepArgs &pargs)
static void	Logdel (char *reqid)
static int	Open (const char *reqid, int &fsz)
static void	Scrub ()
static int	setParms (char *ldir)
static int	setParms (int stime, int skeep)

Additional Inherited Members
Public Attributes inherited from XrdJob
const char *	Comment
XrdJob *	NextJob

Detailed Description

Definition at line 83 of file XrdXrootdPrepare.hh.

Constructor & Destructor Documentation

XrdXrootdPrepare()

XrdXrootdPrepare::XrdXrootdPrepare	(	XrdSysError *	lp,
		XrdScheduler *	sp,
		bool	nomsg )

Definition at line 79 of file XrdXrootdPrepare.cc.

                                               : XrdJob("Prep log scrubber")
{eDest    = errp;
 SchedP   = sp;
 if (LogDir) SchedP->Schedule((XrdJob *)this, scrubtime+time(0));
//  else if (!nomsg) eDest->Say("Config warning: 'xrootd.prepare logdir' "
//                              "not specified; prepare tracking disabled.");
}

References XrdJob::XrdJob(), XrdScheduler::Schedule(), and XrdJob::XrdScheduler.

Here is the call graph for this function:

~XrdXrootdPrepare()

XrdXrootdPrepare::~XrdXrootdPrepare ( )

inline

Definition at line 108 of file XrdXrootdPrepare.hh.

{}   // Never gets deleted

Member Function Documentation

Close()

static int XrdXrootdPrepare::Close ( int fd )

inlinestatic

Definition at line 87 of file XrdXrootdPrepare.hh.

{return close(fd);}

References close.

DoIt()

void XrdXrootdPrepare::DoIt ( )

inlinevirtual

Implements XrdJob.

Definition at line 89 of file XrdXrootdPrepare.hh.

                         {Scrub();
                          SchedP->Schedule((XrdJob *)this, scrubtime+time(0));
                         }

References XrdJob::XrdJob(), and Scrub().

Here is the call graph for this function:

List()

int XrdXrootdPrepare::List ( XrdXrootdPrepArgs & pargs, char * resp, int resplen )

static

Definition at line 92 of file XrdXrootdPrepare.cc.

{
   char *up, path[2048];
   struct dirent *dp;
   struct stat buf;
   int rc;
 
// If logging is not supported, return eof
//
   if (!LogDir) return -1;
 
// Check if this is the first call
//
   if (!pargs.dirP)
      {if (!(pargs.dirP = opendir((const char *)LogDir)))
          {eDest->Emsg("List", errno, "open prep log directory", LogDir);
           return -1;
          }
       if (pargs.reqid) pargs.reqlen = strlen(pargs.reqid);
       if (pargs.user)  pargs.usrlen = strlen(pargs.user);
      }
 
// Find the next entry that satisfies the search criteria
//
   errno = 0;
   while((dp = readdir(pargs.dirP)))
     {if (!(up = (char *) index((const char *)dp->d_name, '_'))) continue;
         if (pargs.reqlen && strncmp(dp->d_name, pargs.reqid, pargs.reqlen))
            continue;
         if (pargs.usrlen)
            if (!up || strcmp((const char *)up+1,(const char *)pargs.user))
               continue;
         strcpy(path, (const char *)LogDir);
         strcpy(path+LogDirLen, (const char *)dp->d_name);
         if (stat((const char *)path, &buf)) continue;
         *up = ' ';
         if ((up = (char *) index((const char *)(up+1), (int)'_'))) *up = ' ';
            else continue;
         if ((up = (char *) index((const char *)(up+1), (int)'_'))) *up = ' ';
            else continue;
         return snprintf(resp, resplen-1, "%s %lld",
                         dp->d_name, (long long) buf.st_mtime);
        }
 
// Completed
//
   if ((rc = errno))
      eDest->Emsg("List", errno, "read prep log directory", LogDir);
   closedir(pargs.dirP);
   pargs.dirP = 0;
   return (rc ? -1 : 0);
}

References closedir, opendir, readdir, XrdXrootdPrepArgs::reqid, stat, and XrdXrootdPrepArgs::user.

Log()

void XrdXrootdPrepare::Log ( XrdXrootdPrepArgs & pargs )

static

Definition at line 149 of file XrdXrootdPrepare.cc.

{
   int rc, pnum = 0, xfd;
   XrdOucTList *tp = pargs.paths;
   char buff[2048], blink[2048];
   struct iovec iovec[2];
 
// If logging not enabled, return
//
   if (!LogDir) return;
 
// Count number of paths in the list
//
   while(tp) {pnum++; tp = tp->next;}
 
// Construct the file name: <reqid>_<user>_<prty>_<numpaths>
//
   snprintf(buff, sizeof(buff)-1, "%s%s_%s_%d_%d", LogDir,
                                  pargs.reqid, pargs.user, pargs.prty, pnum);
 
// Create the file
//
    if ((xfd = open(buff, O_WRONLY|O_CREAT|O_TRUNC,0644)) < 0)
       {eDest->Emsg("Log", errno, "open prep log file", buff);
        return;
       }
 
// Write all the paths into the file, separating each by a space
//
   iovec[1].iov_base = (char *)" ";
   iovec[1].iov_len  = 1;
   tp = pargs.paths;
   while(tp)
        {if (tp->next == 0) iovec[1].iov_base = (char *)"\n";
         iovec[0].iov_base = tp->text;
         iovec[0].iov_len  = strlen(tp->text);
         do {rc = writev(xfd, (const struct iovec *)iovec, 2);}
             while(rc < 0 && errno == EINTR);
         if (rc < 0)
            {eDest->Emsg("Log", errno, "write prep log file", buff);
             close(xfd);
             return;
            }
         tp = tp->next;
        }
 
// Create a symlink to the file
//
   close(xfd);
   strcpy(blink, LogDir); 
   strlcpy(blink+LogDirLen, pargs.reqid, sizeof(blink)-1);
   if (symlink((const char *)buff, (const char *)blink))
      {eDest->Emsg("Log", errno, "create symlink to prep log file", buff);
       return;
      }
}

References close, XrdOucTList::next, open, XrdXrootdPrepArgs::paths, XrdXrootdPrepArgs::prty, XrdXrootdPrepArgs::reqid, strlcpy(), XrdOucTList::text, XrdXrootdPrepArgs::user, and writev.

Here is the call graph for this function:

Logdel()

void XrdXrootdPrepare::Logdel ( char * reqid )

static

Definition at line 210 of file XrdXrootdPrepare.cc.

{
   int rc;
   char path[MAXPATHLEN+256], buff[MAXPATHLEN+1];
 
// If logging not enabled, return
//
   if (!LogDir || strlen(reqid) > 255) return;
 
// Construct the file name of the symlink
//
   strcpy(path, (const char *)LogDir);
   strcpy(&path[LogDirLen], (const char *)reqid);
 
// Read the symlink contents for this request
//
   if ((rc = readlink((const char *)path, buff, sizeof(buff)-1)) < 0)
      {if (errno != ENOENT) eDest->Emsg("Logdel",errno,"read symlink",path);
       return;
      }
 
// Delete the file, then the symlink
//
   buff[rc] = '\0';
   if (unlink((const char *)buff)
   &&  errno != ENOENT) eDest->Emsg("Logdel",errno,"remove",buff);
      else TRACE(DEBUG, "Logdel removed " <<buff);
   if (unlink((const char *)path)
   &&  errno != ENOENT) eDest->Emsg("Logdel", errno, "remove", path);
      else TRACE(DEBUG, "Logdel removed " <<path);
}

References DEBUG, TRACE, and unlink.

Open()

int XrdXrootdPrepare::Open ( const char * reqid, int & fsz )

static

Definition at line 246 of file XrdXrootdPrepare.cc.

{
   int fd;
   char path[MAXPATHLEN+264];
   struct stat buf;
 
// If logging is not supported, indicate so
//
   if (!LogDir) return -ENOTSUP;
 
// Construct the file name
//
   strcpy(path, (const char *)LogDir);
   strcpy(path+LogDirLen, reqid);
 
// Open the file and return the file descriptor
//
   if ((fd = open((const char *)path, O_RDONLY)) < 0) return -errno;
 
// Get the file size
//
   if (fstat(fd, &buf) != 0) {
     close(fd);
     return -errno;
   }
 
   fsz = buf.st_size;
 
   return fd;
}

References close, fstat, open, and stat.

Scrub()

void XrdXrootdPrepare::Scrub ( )

static

Definition at line 281 of file XrdXrootdPrepare.cc.

{
   DIR *prepD;
   time_t stale = time(0) - scrubkeep;
   char *up, path[2048], *fn = path+LogDirLen;
   struct dirent *dp;
   struct stat buf;
 
// If logging is not supported, return eof
//
   if (!LogDir) return;
 
// Open the log directory
//
   if (!(prepD = opendir((const char *)LogDir)))
      {eDest->Emsg("Scrub", errno, "open prep log directory", LogDir);
       return;
      }
   strcpy(path, (const char *)LogDir);
 
// Delete all stale entries
//
   errno = 0;
   while((dp = readdir(prepD)))
     {if (!(up = (char *) index((const char *)dp->d_name, '_'))) continue;
         strcpy(fn, (const char *)dp->d_name);
         if (stat((const char *)path, &buf)) continue;
         if (buf.st_mtime <= stale)
            {TRACE(DEBUG, "Scrub removed stale prep log " <<path);
             unlink((const char *)path);
             *(fn+(up-dp->d_name)) = '\0';
             unlink((const char *)path);
             errno = 0;
            }
        }
 
// All done
//
   if (errno)
      eDest->Emsg("List", errno, "read prep log directory", LogDir);
   closedir(prepD);
}

References closedir, DEBUG, opendir, readdir, stat, TRACE, and unlink.

Referenced by DoIt().

Here is the caller graph for this function:

setParms() [1/2]

int XrdXrootdPrepare::setParms ( char * ldir )

static

Definition at line 334 of file XrdXrootdPrepare.cc.

{
   char path[2048];
   struct stat buf;
   int plen;
 
// If parm not supplied, ignore call
//
   if (!ldir) return 0;
 
// Make sure we have appropriate permissions for this directory
//
   if (access((const char *)ldir, X_OK | W_OK | R_OK) || stat(ldir, &buf))
      return -errno;
   if ((buf.st_mode & S_IFMT) != S_IFDIR) return -ENOTDIR;
 
// Create the path name
//
   if (LogDir) free(LogDir);
   LogDir = 0;
   plen = strlen(ldir);
   strcpy(path, ldir);
   if (path[plen-1] != '/') path[plen++] = '/';
   path[plen] = '\0';
 
// Save the path and return
//
   LogDir    = strdup(path);
   LogDirLen = strlen(LogDir);
   return 0;
}

References access, and stat.

setParms() [2/2]

int XrdXrootdPrepare::setParms ( int stime, int skeep )

static

Definition at line 328 of file XrdXrootdPrepare.cc.

{if (stime > 0) scrubtime = stime;
 if (keep  > 0) scrubkeep = keep;
 return 0;
}

---

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

• XrdXrootdPrepare.hh
• XrdXrootdPrepare.cc