#include <XrdOssArcConfig.hh>

Collaboration diagram for XrdOssArcConfig:

Public Member Functions
	XrdOssArcConfig ()
	~XrdOssArcConfig ()
bool	BuildPath (const char what, const char baseP, const char addP, char &destP, int mode=0)
bool	Configure (const char cfn, const char parms, XrdOucEnv *envP)
int	GenTapePath (const char dsn, char buff, int bSZ, bool addafn=false)

Public Attributes
char *	admnPath
const char *	ArchiverName
char *	ArchiverPath
XrdOucProg *	ArchiverProg
char *	ArchiverSave
long long	arcSZ_MaxV
long long	arcSZ_MinV
bool	arcSZ_Skip
long long	arcSZ_Want
int	arcvPathLEN
char *	arcvPathLFN
char *	arFName
char *	arfSfx
int	arfSfxLen
int	bkpFSt
bool	bkpLocal
int	bkpMax
long long	bkpMinF
int	bkpPoll
const char *	BkpUtilEOL
const char *	BkpUtilName
char *	BkpUtilPath
XrdOucProg *	BkpUtilProg
int	bkupPathLEN
char *	bkupPathLFN
char *	doneBKP
char *	dsetPathLFN
char *	dsetRepoPFN
char *	dstRSE
char *	manCKS
int	maxStage
const char *	metaBKP
const char *	metaIDX
char *	MssComCmd
const char *	MssComName
char *	MssComPath
XrdOucProg *	MssComProg
char *	MssComRoot
char *	needBKP
const char *	PostArcName
char *	PostArcPath
XrdOucProg *	PostArcProg
const char *	PrepArcName
char *	PrepArcPath
XrdOucProg *	PrepArcProg
int	r_maxItems
char *	srcData
char *	srcRSE
char *	stagePath
int	stopChk
XrdOssArcStopMon *	stopMon
char *	stopPath
char *	tapePath
int	tapePathLEN
char *	utilsPath
int	wtpStage

Detailed Description

Definition at line 37 of file XrdOssArcConfig.hh.

Constructor & Destructor Documentation

◆ XrdOssArcConfig()

XrdOssArcConfig::XrdOssArcConfig ( )

Definition at line 99 of file XrdOssArcConfig.cc.

{
// Establish the defaults 
//
   BkpUtilPath = strdup("XrdOssArc_BkpUtils");
   BkpUtilName = BkpUtilPath;
 
   PrepArcPath = 0;
   PrepArcName = 0;
 
   PostArcPath = 0;
   PostArcName = 0;
 
   ArchiverPath= strdup("XrdOssArc_Archiver");
   ArchiverName= ArchiverPath;
   ArchiverSave= 0;
 
   MssComPath  = strdup("XrdOssArc_MssCom");
   MssComName  = MssComPath;
   MssComCmd   = 0;
   MssComRoot  = 0;
 
   arcvPathLFN = strdup("/archive/");
   arcvPathLEN = strlen(arcvPathLFN);
   bkupPathLFN = strdup("/backup/");
   bkupPathLEN = strlen(bkupPathLFN);
   dsetPathLFN = strdup("/dataset/");
   dsetRepoPFN = 0;
 
   const char*atmp;
   if ((atmp = getenv("XRDADMINPATH"))) 
      {std::string as = atmp;
       if (as.back() != '/') as.append("/");
       as.append("OssArc/");
       admnPath = strdup(as.c_str());
      }
   stopPath    = 0;
 
   srcData     = strdup("");
   stagePath   = strdup("/tmp/stage");
   tapePath    = strdup("/TapeBuffer");
   tapePathLEN = strlen(tapePath);
   utilsPath   = strdup("/usr/local/etc");
 
   stopMon     = 0;
 
   metaBKP     = "arcBackup";
   metaIDX     = "arcIndex";
   doneBKP     = 0;
   needBKP     = 0;
   dstRSE      = 0;
   srcRSE      = 0;
   manCKS      = strdup("adler32");
 
   bkpMinF     = -20;
   bkpMax      = 2;
   bkpPoll     = 15*60;
   bkpFSt      = -1;  // Eventual default is bkpPoll/3
   maxStage    = 30;
   wtpStage    = 30;
   r_maxItems  = 1000;
   arFName     = strdup("Archive.zip");
   arfSfx      = strdup(".zip");
   arfSfxLen   = 4;
   stopChk     = 10;
   bkpLocal    = true;
 
   arcSZ_Skip  = false;
   arcSZ_Want  = 0;  // The XrdOssArc_BkpUtils defines the default
   arcSZ_MinV  = 0;
   arcSZ_MaxV  = 0;
 
   if (getenv("XRDOSSARC_DEBUG") || getenv("XRDDEBUG"))
      ArcTrace.What |= TRACE_Debug;
}

References admnPath, ArchiverName, ArchiverPath, ArchiverSave, arcSZ_MaxV, arcSZ_MinV, arcSZ_Skip, arcSZ_Want, XrdOssArcGlobals::ArcTrace, arcvPathLEN, arcvPathLFN, arFName, arfSfx, arfSfxLen, bkpFSt, bkpLocal, bkpMax, bkpMinF, bkpPoll, BkpUtilName, BkpUtilPath, bkupPathLEN, bkupPathLFN, doneBKP, dsetPathLFN, dsetRepoPFN, dstRSE, manCKS, maxStage, metaBKP, metaIDX, MssComCmd, MssComName, MssComPath, MssComRoot, needBKP, PostArcName, PostArcPath, PrepArcName, PrepArcPath, r_maxItems, srcData, srcRSE, stagePath, stopChk, stopMon, stopPath, tapePath, tapePathLEN, TRACE_Debug, utilsPath, and wtpStage.

◆ ~XrdOssArcConfig()

XrdOssArcConfig::~XrdOssArcConfig ( )

inline

Definition at line 49 of file XrdOssArcConfig.hh.

49{} // Never gets deleted

Member Function Documentation

◆ BuildPath()

bool XrdOssArcConfig::BuildPath	(	const char *	what,
		const char *	baseP,
		const char *	addP,
		char *&	destP,
		int	mode = 0 )

Definition at line 179 of file XrdOssArcConfig.cc.

{
   char lclPath[MAXPATHLEN];
   int rc;
   
// Get the local path to the base directory
//
   if ((rc = GenLocalPath(baseP, lclPath, sizeof(lclPath))))
      {Elog.Emsg("Config", rc, "configure", what);
       return false;
      }
 
// Copy the path for further modification
//
   std::string tmpStr(lclPath);
 
// Trimp off trailing slashes
//
   while(tmpStr.back() == '/') tmpStr.pop_back();
 
// Add any additional element
//
   if (addP) tmpStr.append(addP);
 
// Create modifiable copy
//
   char* modStr = strdup(tmpStr.c_str());
 
// Check if we need to create the full path
//
   if (mode)
      {int rc = XrdOucUtils::makePath(modStr, mode); 
       if (rc)
          {std::string msgT("create ");
           msgT.append(what);
           Elog.Emsg("Config", rc, msgT.c_str(), tmpStr.c_str());
           free(modStr);
           return false;
          }
       }
 
// Set destination and return success
//
   destP = modStr;
   return true;
}

References XrdOssArcGlobals::Elog, and XrdOucUtils::makePath().

Referenced by Configure().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Configure()

bool XrdOssArcConfig::Configure	(	const char *	cfn,
		const char *	parms,
		XrdOucEnv *	envP )

Definition at line 231 of file XrdOssArcConfig.cc.

{
   TraceInfo("Configure", 0);
   bool NoGo = false;
 
// Read and process the config file
//
   if (!ConfigXeq(cfn, parms, envP)) return false;
 
// Set the external debug flag as needed
//
   if (ArcTrace.What & (TRACE_Debug | TRACE_Save))
      XrdOucEnv::Export("XRDOSSARC_DEBUG",ArcTrace.What & TRACE_Save ? "2":"1");
 
// Make sure that the rse declarations have been specified
//
   if (dstRSE && srcRSE)
      {std::string tmp;
       XrdOucEnv::Export("XRDOSSARC_DSTRSE", dstRSE);
       DEBUG("exporting XRDOSSARC_DSTRSE="<<dstRSE);
       XrdOucEnv::Export("XRDOSSARC_SRCRSE", srcRSE);
       DEBUG("exporting XRDOSSARC_SRCRSE="<<srcRSE);
 
       tmp = dstRSE;
       tmp += ":need";
       needBKP = strdup(tmp.c_str());
       tmp  = dstRSE;
       tmp += ":done";
       doneBKP = strdup(tmp.c_str());
      } else {
       Elog.Say("Config mistake: required 'rsedcl' directive not specified!");
       NoGo = true;
      }
 
// Export values needed by the metadata script
//
   XrdOucEnv::Export("XRDOSSARC_MAXITEMS", r_maxItems);
 
// Export manifest checksum, unless none wanted
//
   if (strcmp(manCKS, "none")) XrdOucEnv::Export("XRDOSSARC_CKSUM", manCKS);
 
// Export archive size parameters if specified
//
   if (arcSZ_Want)
      {char buff[1024];
       snprintf(buff, sizeof(buff), "%lld %lld %lld %d", arcSZ_Want,
                arcSZ_MinV, arcSZ_MaxV, (int)arcSZ_Skip);
        XrdOucEnv::Export("XRDOSSARC_SIZE", buff);
      }
 
// Handle the admin path
//
   if (admnPath)
      {int rc = XrdOucUtils::makePath(admnPath, S_IRWXU | S_IRGRP);
       if (rc) {Elog.Emsg("Config", rc, "create admin path", admnPath);
                NoGo = true;
               }
          else if (!Usable(admnPath, "admin path", false)) NoGo = true;
      }
 
// Handle the stop file path
//
   if (!stopPath) stopPath = admnPath;
      else {std::string ss = stopPath;
            if (ss.back() != '/')
               {ss.append("/");
                free(stopPath);
                stopPath = strdup(ss.c_str());
               }
           }
 
// Create the stop monitor
//
   if (!stopPath)
      {Elog.Emsg("Config", "Unable to determine the stopfile path!");
       NoGo = true;
      } else {
       if (!Usable(stopPath, "stopfile path", false)) NoGo = true;
          else if (!NoGo)
                  {bool uOK;
                   stopMon = new XrdOssArcStopMon(stopPath, stopChk, uOK);
                   if (!uOK)
                      {NoGo = true;
                       delete stopMon;
                       stopMon = 0;
                      }
                  }
      }     
 
// Verify that the tape buffer is usable
//
   if (!Usable(tapePath, "tape buffer path", false)) NoGo = true;
   tapePathLEN = strlen(tapePath);
 
// Initialize the tape buffer resourse monitor
//
   if (bkpFSt < 0)
      {bkpFSt = bkpPoll/3;
       if (bkpFSt < 30) bkpFSt = 30;
      }
   if (!fsMon.Init(tapePath, bkpMinF, bkpFSt)) NoGo = true;
 
// Verify that the data source mount point is usable
//
   if (*srcData)
      {struct stat Stat;
       if (stat(srcData, &Stat))
          {Elog.Emsg("Config", errno, "use srcdata path", srcData);
           NoGo = true;
          }
      }
 
// Create the backup staging path
//
   if (!BuildPath("dataset backup arena", dsetPathLFN, "/4bkp/",
                  dsetRepoPFN, S_IRWXU|S_IRGRP|S_IXGRP))
      NoGo = true;
 
// Create the program that returns the datasets that need to be backed up.
// It also is the one that manipulates the backup status of a dataset.
//
   BkpUtilProg = new XrdOucProg(&Elog);
   ConfigPath(&BkpUtilPath, utilsPath);
   if (BkpUtilProg->Setup(BkpUtilPath)) NoGo = true;
      else {const char* rslash = rindex(BkpUtilPath, '/');
            BkpUtilName = (rslash ? rslash+1 : BkpUtilPath);
           }
 
// Create program to communicate with the MSS
//
   MssComProg = new XrdOucProg(&Elog);
   ConfigPath(&MssComPath, utilsPath);
   if (MssComProg->Setup(MssComPath)) NoGo = true;
      else {const char* rslash = rindex(MssComPath, '/');
            MssComName = (rslash ? rslash+1 : MssComPath);
           }
 
// Export envars that the programs needs
//
   if (MssComCmd)
      {XrdOucEnv::Export("XRDOSSARC_MSSCMD",  MssComCmd);
       DEBUG("Exporting XRDOSSARC_MSSCMD="<<MssComCmd);
      }
   if (MssComRoot)
      {XrdOucEnv::Export("XRDOSSARC_MSSROOT", MssComRoot);
       DEBUG("exporting XRDOSSARC_MSSROOT="<<MssComRoot);
      } else MssComRoot = strdup(""); 
 
// Create the pre archiver program if it has been specified
//
   if (PrepArcPath)
      {PrepArcProg = new XrdOucProg(&Elog);
       ConfigPath(&PrepArcPath, utilsPath);
       if (PrepArcProg->Setup(PrepArcPath)) NoGo = true;
          else {const char* rslash = rindex(PrepArcPath, '/');
                PrepArcName = (rslash ? rslash+1 : PrepArcPath);
               }
      } else PrepArcProg = 0;
 
// Create the post archiver program if it has been specified
//
   if (PostArcPath)
      {PostArcProg = new XrdOucProg(&Elog);
       ConfigPath(&PostArcPath, utilsPath);
       if (PostArcProg->Setup(PostArcPath)) NoGo = true;
          else {const char* rslash = rindex(PostArcPath, '/');
                PostArcName = (rslash ? rslash+1 : PostArcPath);
               }
      } else {
       PostArcProg = 0;
       PostArcName = PostArcPath = strdup("");
      }
 
// Create the program to be used to create the archive
//
   ArchiverProg = new XrdOucProg(&Elog);
   ConfigPath(&ArchiverPath, utilsPath);
   if (ArchiverProg->Setup(ArchiverPath)) NoGo = true;
      else {const char* rslash = rindex(ArchiverPath, '/');
            ArchiverName = (rslash ? rslash+1 : ArchiverPath);
           }
 
// Setup the remote copy command the archiver should use for backups
//
   if (bkpLocal)
      {if (ArchiverSave) free(ArchiverSave);
       ArchiverSave = strdup("");
      } else {
       if (!ArchiverSave) ArchiverSave = MssComPath;
       else ConfigPath(&ArchiverSave, utilsPath);
       DEBUG("Archiver remote copycmd="<<ArchiverSave);
      }
 
// Make sure all the required metadata keys have been defined
//
   DEBUG("Running "<<BkpUtilName<<" addkey "<<metaBKP<<' '<<metaIDX);
   if (BkpUtilProg->Run("addkey", metaBKP, metaIDX))
      Elog.Emsg("Config","Unable to create/verify metadata keys; continuing...");
 
// Start the backup process. 
//
   std::vector<XrdOssArcBackup*> bkpVec;
   XrdOssArcBackup* bkpP;
   if (bkpScopes.empty())
      {Elog.Emsg("Config", "No backup scopes specified!"); NoGo = true;
      } else {
       bool isOK;
       for (auto it = bkpScopes.begin(); it != bkpScopes.end(); ++it)
           {bkpP = new XrdOssArcBackup(it->c_str(), isOK);
            if (!isOK)
               {NoGo = true;
                Elog.Emsg("Config", "Unable to start backing up scope",
                                    it->c_str());
                delete bkpP;
               } else bkpVec.push_back(bkpP);
           }
      }
 
// Start the configured number of backup workers The workers will wait for
// backup tasks which will come shortly as we will start them once we have
// dispatched workers. However, if we failed in any way, nothing is started.
//
   if (!NoGo)
      {XrdOssArcBackup::StartWorkers(bkpMax);
       for (auto it = bkpVec.begin(); it != bkpVec.end(); it++) 
           {Elog.Say("Config process: scheduling backup for scope ",
                                      (*it)->theScope());
            schedP->Schedule(*it, time(0)+3);
           }
      }
 
// All done
//
   return !NoGo;
}