#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) {}

◆ ~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, XrdSysMutex::Lock(), numBytes, Owner, XrdOssArcFSMon::Release(), relSpace, theDSN, and XrdSysMutex::UnLock().

Here is the call graph for this function:

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;
 }

References XrdOssArcStopMon::Activate(), XrdOssArcBackup::Archive(), XrdOssArcBackup::Arena(), btSem, XrdCms::Config, XrdOssArcStopMon::Deactivate(), DEBUG, XrdOssArcCompose::DSN2Dir(), XrdOssArcGlobals::Elog, XrdSysError::Emsg(), XrdOssArcGlobals::fsMon, XrdOucStream::GetLine(), XrdOucUtils::makePath(), numBytes, numFiles, Owner, XrdOssArcFSMon::Permit(), theDSN, theScope, TRACE_Save, TraceInfo, TRACING, and XrdSysSemaphore::Wait().

Here is the call graph for this function:

Member Data Documentation

◆ btSem

XrdSysSemaphore XrdOssArcBackupTask::btSem

Definition at line 57 of file XrdOssArcBackup.hh.

Referenced by BkpXeq(), and XrdOssArcFSMon::Release().

◆ numBytes

size_t XrdOssArcBackupTask::numBytes

Definition at line 54 of file XrdOssArcBackup.hh.

Referenced by ~XrdOssArcBackupTask(), BkpXeq(), XrdOssArcFSMon::Permit(), and XrdOssArcFSMon::Release().

◆ numFiles

int XrdOssArcBackupTask::numFiles

Definition at line 55 of file XrdOssArcBackup.hh.

Referenced by BkpXeq().

◆ Owner

XrdOssArcBackup& XrdOssArcBackupTask::Owner

Definition at line 51 of file XrdOssArcBackup.hh.

Referenced by ~XrdOssArcBackupTask(), and BkpXeq().

◆ relSpace

bool XrdOssArcBackupTask::relSpace

Definition at line 56 of file XrdOssArcBackup.hh.

Referenced by ~XrdOssArcBackupTask(), and XrdOssArcFSMon::Permit().

◆ theDSN

char* XrdOssArcBackupTask::theDSN

Definition at line 53 of file XrdOssArcBackup.hh.