#include <XrdOssArcBackup.hh>

Collaboration diagram for XrdOssArcBackupTask:

Public Member Functions
	XrdOssArcBackupTask (XrdOssArcBackup &who, char *dsn)
	~XrdOssArcBackupTask ()
bool	BkpXeq ()

Public Attributes
XrdSysSemaphore	btSem
size_t	numBytes
int	numFiles
XrdOssArcBackup &	Owner
bool	relSpace
char *	theDSN
const char *	theScope

Detailed Description

Definition at line 47 of file XrdOssArcBackup.hh.

Constructor & Destructor Documentation

◆ XrdOssArcBackupTask()

XrdOssArcBackupTask::XrdOssArcBackupTask	(	XrdOssArcBackup &	who,
		char *	dsn )

Definition at line 92 of file XrdOssArcBackup.cc.

                                 : Owner(who), theScope(who.Scope), theDSN(dsn),
                                   numBytes(0), numFiles(0), relSpace(false),
                                   btSem(0) {}

References btSem, numBytes, numFiles, Owner, relSpace, theDSN, and theScope.

◆ ~XrdOssArcBackupTask()

XrdOssArcBackupTask::~XrdOssArcBackupTask ( )

Definition at line 97 of file XrdOssArcBackup.cc.

{
// Remove entry of the dataset name from the owner's set
//
   Owner.dsBkpSetMtx.Lock();
   Owner.dsBkpSet.erase(theDSN);
   Owner.dsBkpSetMtx.UnLock();
 
// Release the space that this request acquired
//
   if (relSpace) fsMon.Release(numBytes);
 
// Since theDSN was shared with the owner's set we can free the storage
//
   free(theDSN);
}

References XrdOssArcGlobals::fsMon, numBytes, Owner, relSpace, and theDSN.

Member Function Documentation

◆ BkpXeq()

bool XrdOssArcBackupTask::BkpXeq ( )

Definition at line 118 of file XrdOssArcBackup.cc.

{
// The first step it to setup the staging area to create an archive. This is
// done using a scipt. The script returns the total number of files and bytes
// that will need to be backed up.
 
// Construct the staging path for archive creation management
//
   TraceInfo("BkpTask", 0);
   XrdOucStream cmdSup;
   char dsnDir[MAXPATHLEN], manPFN[MAXPATHLEN];
   int n, rc;
 
// We create an instance of the stop monitor. If a stop is in effect, it
// will not complete construction until the stop file is removed.
//
   XrdOssArcStopMon stopMon(Config.stopMon);
 
// Compose the arena path. Note that our arena path already ends with a slash
//
   n = snprintf(dsnDir, sizeof(dsnDir), "%s%s/", Owner.Arena(),
                        XrdOssArcCompose::DSN2Dir(theDSN).c_str());
   if (n >= (int)sizeof(dsnDir))
      {Elog.Emsg("Backup",ENAMETOOLONG,"create arena path for dataset",theDSN);
       return false;
      }
 
// We now must create the directory path to the arena 
//
   if ((rc = XrdOucUtils::makePath(dsnDir, S_IRWXU|S_IRGRP|S_IXGRP)))
       {Elog.Emsg("Backup", rc, "create dataset backup arena", dsnDir);
       return false;
      }
 
// Generate name of the manifest file. This is needed by the preparc and
// postarc utilities plus we want to add it to the zip archive as provenance.
//
   n = snprintf(manPFN, sizeof(manPFN), "%sManifest", dsnDir);
   if (n >= (int)sizeof(manPFN))
      {Elog.Emsg("Backup",ENAMETOOLONG,"create bkp manifest for dataset",
                  theDSN);
       return false;
      }
 
// Construct the argument list
//
   const char* supArgv[] = {"setup", Config.srcRSE, theScope, theDSN, dsnDir, 
                            Config.srcData, manPFN};
   int supArgc = sizeof(supArgv)/sizeof(char*);
 
// Do some tracing
//
   DEBUG("Running "<<Config.BkpUtilName<<' '<<supArgv[0]<<' '<<supArgv[1]<<
                  ' '<<supArgv[2]<<' '<<supArgv[3]<<' '<<supArgv[4]<<
                  ' '<<supArgv[5]<<' '<<supArgv[6]);
 
// Run the setup script which prepares the dataset for archiving. It should 
// output a single line: <files> <bytes>
//
   if (!(rc = Config.BkpUtilProg->Run(&cmdSup, supArgv, supArgc)))
      {char *lp, *retStr = 0;
       size_t vb;
       int vf;
       bool isOK = false;
       while((lp = cmdSup.GetLine())) if (!retStr) retStr = strdup(lp);
 
       if (retStr)
          {n = sscanf(retStr, "%d %zu", &vf, &vb);
           if (n == 2) {numFiles = vf, numBytes = vb; isOK = true;}
              else {char etxt[1024];
                    snprintf(etxt, sizeof(etxt),
                             "%s setup returned bad output '",
                             Config.BkpUtilName);
                    Elog.Emsg("Backup", etxt, retStr,"'");
                   }
           free(retStr);
          } else {
           Elog.Emsg("Backup",Config.BkpUtilName,"setup returned no output");
           return false;
          }
 
       Config.BkpUtilProg->RunDone(cmdSup); // This may kill the process
       if (!isOK) return false;
      } else {
       Elog.Emsg("Backup",rc, "run setup via", Config.BkpUtilName);
       return false;                                                     
      }
 
// We can only proceed if there is enough space to hold the backup. This only
// applies to local backups. Remote backups have unlimited space.
//
   if (Config.bkpLocal)
      while(!fsMon.Permit(this))   
         {char buff[1024];
          snprintf(buff,sizeof(buff),"Insufficient free space; defering "
                                     "archiving of %s:%s", theScope, theDSN);
          Elog.Emsg("BkpXeq", buff);
          stopMon.Deactivate();
          btSem.Wait();               
          stopMon.Activate();
          snprintf(buff,sizeof(buff),"Retrying to archive %s:%s",
                                     theScope, theDSN);
         }
 
// bBefore we create the archive, check if we must run a pre-archive utility.
// These utilities usually pre-fetch the files that we will be archiving.
//
   if (Config.PrepArcProg)
      {XrdOucStream prpSup;
       const char* prpArgv[] = {"prepare", theScope, manPFN};
       int prpArgc = sizeof(prpArgv)/sizeof(char*);
 
       DEBUG("Running "<<Config.PrepArcName<<' '<<prpArgv[0]<<' '<<prpArgv[1]
                  <<' '<<prpArgv[2]);
 
       if (!(rc = Config.PrepArcProg->Run(&prpSup, prpArgv, prpArgc)))
          {char* lp;
           while((lp = prpSup.GetLine())) {}
           Config.PrepArcProg->RunDone(prpSup); // This may kill the process
          } else {
           Elog.Emsg("Backup", rc, "run preparc", Config.PrepArcName);
           return false;                                                     
          }
      }
 
// Run the archive script
//
   if (!Owner.Archive(theDSN, dsnDir)) return false;
 
// Run post-archive script if we need to
//
   if (Config.PostArcProg)
      {XrdOucStream pstSup;
       const char* pstArgv[] = {"dispose", theScope, manPFN};
       int pstArgc = sizeof(pstArgv)/sizeof(char*);
 
       DEBUG("Running "<<Config.PrepArcName<<' '<<pstArgv[0]<<' '<<pstArgv[1]
                  <<' '<<pstArgv[2]);
 
       if (!(rc = Config.PostArcProg->Run(&pstSup, pstArgv, pstArgc)))
          {char* lp;
           while((lp = pstSup.GetLine())) {}
           Config.PostArcProg->RunDone(pstSup); // This may kill the process
          } else {
           Elog.Emsg("Backup", rc, "run postarc", Config.PostArcName);
           return false;                                                     
          }
      }
 
// We can now safely mark this dataset as having been backed up
//
   XrdOucStream cmdFin;
   const char* finArgv[] = {"finish", Config.srcRSE, theScope, theDSN, dsnDir,
                            Config.metaBKP, Config.doneBKP};
   int finArgc = sizeof(finArgv)/sizeof(char*);
 
// If the debug setting indicates we need to save the setup, disallow delete
//
   if (TRACING(TRACE_Save)) finArgv[4] = "";
 
// Do some tracing
//
   DEBUG("Running "<<Config.BkpUtilName<<' '<<finArgv[0]<<' '<<finArgv[1]<<
                  ' '<<finArgv[2]<<' '<<finArgv[3]<<' '<<
                     (*finArgv[4] ? finArgv[4] : "n/d")<<
                  ' '<<finArgv[5]<<' '<<finArgv[6]);
 
// Run the setup script which sets the dataset backup metadata to completed
//
   if (!(rc = Config.BkpUtilProg->Run(&cmdFin, finArgv, finArgc)))
      {while((cmdFin.GetLine())) {}
       Config.BkpUtilProg->RunDone(cmdFin); // This may kill the process
      } else {
       Elog.Emsg("Backup",rc, "run finish via", Config.BkpUtilName);
       return false;                                                     
      }
 
// All done
//
   return true;
}