Loading...
Searching...
No Matches
XrdXrootdGSReal.cc
Go to the documentation of this file.
/******************************************************************************/
/* */
/* X r d X r o o t d G S R e a l . h h */
/* */
/* (c) 2019 by the Board of Trustees of the Leland Stanford, Jr., University */
/* All Rights Reserved */
/* Produced by Andrew Hanushevsky for Stanford University under contract */
/* DE-AC02-76-SFO0515 with the Department of Energy */
/* */
/* This file is part of the XRootD software suite. */
/* */
/* XRootD is free software: you can redistribute it and/or modify it under */
/* the terms of the GNU Lesser General Public License as published by the */
/* Free Software Foundation, either version 3 of the License, or (at your */
/* option) any later version. */
/* */
/* XRootD is distributed in the hope that it will be useful, but WITHOUT */
/* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or */
/* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public */
/* License for more details. */
/* */
/* You should have received a copy of the GNU Lesser General Public License */
/* along with XRootD in a file called COPYING.LESSER (LGPL license) and file */
/* COPYING (GPL license). If not, see <http://www.gnu.org/licenses/>. */
/* */
/* The copyright holder's institutional names and contributor's names may not */
/* be used to endorse or promote products derived from this software without */
/* specific prior written permission of the institution or contributor. */
/******************************************************************************/
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <sys/uio.h>
#include "Xrd/XrdScheduler.hh"
#include "XrdNet/XrdNetMsg.hh"
#include "XrdSys/XrdSysPlatform.hh"
#include "XrdXrootd/XrdXrootdGSReal.hh"
/******************************************************************************/
/* G l o b a l s */
/******************************************************************************/
namespace XrdXrootdMonInfo
{
extern XrdScheduler *Sched;
extern XrdSysError *eDest;
extern char *monHost;
extern char *kySID;
extern long long mySID;
extern int startTime;
extern char *SidCGI[4];
extern char *SidJSON[4];
}
using namespace XrdXrootdMonInfo;
/******************************************************************************/
/* C o n s t r u c t o r */
/******************************************************************************/
XrdXrootdGSReal::XrdXrootdGSReal(const XrdXrootdGSReal::GSParms &gsParms,
bool &aOK)
: XrdJob("GStream"), XrdXrootdGStream(*this),
Hello(gsParms.Opt & XrdXrootdGSReal::optNoID
|| gsParms.Hdr == XrdXrootdGSReal::hdrNone
? 0 : gsParms.dest, gsParms.Fmt),
pSeq(0), pSeqID(0), pSeqDID(0), binHdr(0),
isCGI(false)
{
static const int minSZ = 1024;
static const int dflSZ = 1024*32;
static const int maxSZ = 1024*64;
int flsT, maxL, hdrLen;
// Do common initialization
//
memset(&hInfo, 0, sizeof(hInfo));
aOK = true;
// Compute the correct size of the UDP buffer
//
if (gsParms.maxL <= 0) maxL = dflSZ;
else if (gsParms.maxL < minSZ) maxL = minSZ;
else if (gsParms.maxL > maxSZ) maxL = maxSZ;
else maxL = gsParms.maxL;
maxL &= ~7; // Doubleword lengths
// Allocate the UDP buffer. Try to keep the data within a single page.
//
int align;
if (maxL >= getpagesize()) align = getpagesize();
else if (maxL >= 2048) align = 2048;
else if (maxL >= 1024) align = 1024;
else align = sizeof(void*);
if (posix_memalign((void **)&udpBuffer, align, maxL)) {aOK = false; return;}
// Setup the header as needed
//
if (gsParms.Hdr == hdrNone)
{hdrLen = 0;
binHdr = 0;
dictHdr = idntHdr0 = idntHdr1 = 0;
} else {
switch(gsParms.Fmt)
{case fmtBin: hdrLen = hdrBIN(gsParms);
break;
case fmtCgi: hdrLen = hdrCGI(gsParms, udpBuffer, maxL);
break;
case fmtJson: hdrLen = hdrJSN(gsParms, udpBuffer, maxL);
break;
default: hdrLen = 0;
}
if (gsParms.Opt & optNoID)
{if (idntHdr0) {free(idntHdr0); idntHdr0 = 0;}
if (idntHdr1) {free(idntHdr1); idntHdr1 = 0;}
}
}
// Setup buffer pointers
//
udpBFirst = udpBNext = udpBuffer + hdrLen;
udpBEnd = udpBuffer + maxL - 1;
tBeg = tEnd = afTime = 0;
// Initialize remaining variables
//
monType = gsParms.Mode;
rsvbytes = 0;
// If we have a specific end-point, then create a network relay to it
//
if (gsParms.dest) udpDest = new XrdNetMsg(eDest, gsParms.dest, &aOK, true);
else udpDest = 0;
// Setup autoflush (a negative value uses the default)
//
if (gsParms.flsT < 0) flsT = XrdXrootdMonitor::Flushing();
else flsT = gsParms.flsT;
afRunning = false;
SetAutoFlush(flsT);
// Construct our user name as in <gNamePI>.0:0@<myhost>
//
char idBuff[1024];
snprintf(idBuff, sizeof(idBuff), "%s.0:0@%s", gsParms.pin, monHost);
// Register ourselves
//
gMon.Register(idBuff, monHost, "xroot");
}
/******************************************************************************/
/* A u t o F l u s h */
/******************************************************************************/
void XrdXrootdGSReal::AutoFlush() // gMutex is locked outside constructor
{
if (afTime && !afRunning)
{Sched->Schedule((XrdJob *)this, time(0)+afTime);
afRunning = true;
}
}
/******************************************************************************/
/* D o I t */
/******************************************************************************/
void XrdXrootdGSReal::DoIt()
{
XrdSysMutexHelper gHelp(gMutex);
// Check if we need to do anything here
//
afRunning = false;
if (afTime)
{if (tBeg && time(0)-tBeg >= afTime) Expel(0);
AutoFlush();
}
}
/******************************************************************************/
/* Private: E x p e l */
/******************************************************************************/
void XrdXrootdGSReal::Expel(int dlen) // gMutex is held
{
// Check if we need to flush this buffer.
//
if (udpBFirst == udpBNext || (dlen && (udpBNext + dlen) < udpBEnd)) return;
int size = udpBNext-udpBuffer;
// Complete the buffer header if may be binary of text
//
if (binHdr)
{binHdr->hdr.pseq++;
binHdr->hdr.plen = htons(static_cast<uint16_t>(size));
binHdr->tBeg = htonl(tBeg);
binHdr->tEnd = htonl(tEnd);
} else {
if (hInfo.pseq)
{char tBuff[32];
if (pSeq >= 999) pSeq = 0;
else pSeq++;
snprintf(tBuff, sizeof(tBuff), "%3d%10u%10u", pSeq,
(unsigned int)tBeg, (unsigned int)tEnd);
if (isCGI)
{char *plus, *bP = tBuff;
while((plus = index(bP, ' '))) {*plus = '+'; bP = plus+1;}
}
memcpy(hInfo.pseq, tBuff, 3);
memcpy(hInfo.tbeg, tBuff+ 3, 10);
memcpy(hInfo.tend, tBuff+13, 10);
}
}
// Make sure the whole thing ends with a null byte
//
*(udpBNext-1) = 0;
// Send off the packet
//
if (udpDest) udpDest->Send(udpBuffer, size);
else XrdXrootdMonitor::Send(monType, udpBuffer, size, false);
// Reset the buffer
//
udpBNext = udpBFirst;
tBeg = tEnd = 0;
}
/******************************************************************************/
/* F l u s h */
/******************************************************************************/
void XrdXrootdGSReal::Flush()
{
XrdSysMutexHelper gHelp(gMutex);
Expel(0);
}
/******************************************************************************/
/* G e t D i c t I D */
/******************************************************************************/
uint32_t XrdXrootdGSReal::GetDictID(const char *text, bool isPath)
{
// If this is binary encoded, the record the mapping and return it
//
if (binHdr) return (isPath ? gMon.MapPath(text) : gMon.MapInfo(text));
// If there are no headers then we can't produce this record
//
uint32_t psq, did = XrdXrootdMonitor::GetDictID(true);
if (!dictHdr) return htonl(did);
// We need to do some additional work to generate non-binary headers here
//
struct iovec iov[3];
char dit = (isPath ? XROOTD_MON_MAPPATH : XROOTD_MON_MAPINFO);
char buff[1024];
// Generate a new packet sequence number
//
gMutex.Lock();
if (pSeqDID >= 999) pSeqDID = 0;
else pSeqDID++;
psq = pSeqDID;
gMutex.UnLock();
// Generate the packet
//
iov[0].iov_base = buff;
iov[0].iov_len = snprintf(buff, sizeof(buff), dictHdr, dit, psq, did);
iov[1].iov_base = (void *)text;
iov[1].iov_len = strlen(text);
iov[2].iov_base = (void *)"\"}";
iov[2].iov_len = 3;
// Now send it off
//
udpDest->Send(iov, (*dictHdr == '{' ? 3 : 2));
return htonl(did);
}
/******************************************************************************/
/* H a s H d r */
/******************************************************************************/
bool XrdXrootdGSReal::HasHdr()
{
return binHdr != 0 || dictHdr != 0;
}
/******************************************************************************/
/* Private: h d r B I N */
/******************************************************************************/
int XrdXrootdGSReal::hdrBIN(const XrdXrootdGSReal::GSParms &gs)
{
// Initialze the udp heaader in the buffer
//
binHdr = (XrdXrootdMonGS*)udpBuffer;
memset(binHdr, 0, sizeof(XrdXrootdMonGS));
binHdr->hdr.code = XROOTD_MON_MAPGSTA;
binHdr->hdr.stod = startTime;
long long theSID = ntohll(mySID) & 0x00ffffffffffffff;
theSID = theSID | (static_cast<long long>(gs.Type) << XROOTD_MON_PIDSHFT);
binHdr->sID = htonll(theSID);
return (int)sizeof(XrdXrootdMonGS);
}
/******************************************************************************/
/* Private: h d r C G I */
/******************************************************************************/
int XrdXrootdGSReal::hdrCGI(const XrdXrootdGSReal::GSParms &gs,
char *buff, int blen)
{
const char *hdr, *plug = "\n";
char hBuff[2048];
int n;
// Pick any needed extensions to this header
//
switch(gs.Hdr)
{case hdrSite: plug = SidCGI[0]; break;
case hdrHost: plug = SidCGI[1]; break;
case hdrInst: plug = SidCGI[2]; break;
case hdrFull: plug = SidCGI[3]; break;
default: break;
}
// Generate the header to use for 'd' or 'i' packets
//
hdr = "code=%%c&pseq=%%u&stod=%u&sid=%s%s&gs.type=%c&did=%%u&data=";
snprintf(hBuff, sizeof(hBuff), hdr, ntohl(startTime), kySID, plug, gs.Type);
dictHdr = strdup(hBuff);
// Generate the headers to use for '=' packets. These have a changeable part
// and a non-changeable part.
//
hdr = "code=%c&pseq=%%u";
snprintf(hBuff, sizeof(hBuff), hdr, XROOTD_MON_MAPIDNT);
idntHdr0 = strdup(hBuff);
hdr = "&stod=%u&sid=%s%s";
n = snprintf(hBuff, sizeof(hBuff), hdr, ntohl(startTime), kySID, SidCGI[3]);
idntHdr1 = strdup(hBuff);
idntHsz1 = n+1;
// Format the header
//
hdr = "code=%c&pseq=$12&stod=%u&sid=%s%s&gs.type=%c"
"&gs.tbeg=$123456789&gs.tend=$123456789%s\n";
n = snprintf(buff, blen, hdr, XROOTD_MON_MAPGSTA, ntohl(startTime),
kySID, plug, gs.Type);
// Return all of the substitution addresses
//
hInfo.pseq = index(buff, '$');
hInfo.tbeg = index(hInfo.pseq+1, '$');
hInfo.tend = index(hInfo.tbeg+1, '$');
// Return the length
//
isCGI = true;
return n;
}
/******************************************************************************/
/* Private: h d r J S N */
/******************************************************************************/
int XrdXrootdGSReal::hdrJSN(const XrdXrootdGSReal::GSParms &gs,
char *buff, int blen)
{
const char *hdr, *plug1 = "", *plug2 = "";
char hBuff[2048];
int n;
// Add any needed extensions to this header
//
if (gs.Hdr != hdrNorm)
{plug1 = ",";
switch(gs.Hdr)
{case hdrSite: plug2 = SidJSON[0]; break;
case hdrHost: plug2 = SidJSON[1]; break;
case hdrInst: plug2 = SidJSON[2]; break;
case hdrFull: plug2 = SidJSON[3]; break;
default: plug1 = ""; break;
}
}
// Generate the header to use for 'd' or 'i' packets
//
hdr = "{\"code\":\"%%c\",\"pseq\":%%u,\"stod\":%u,\"sid\":%s%s%s,"
"\"gs\":{\"type\":\"%c\"},\"did\":%%u,\"data\":\"";
snprintf(hBuff, sizeof(hBuff), hdr, ntohl(startTime), kySID,
plug1, plug2, gs.Type);
dictHdr = strdup(hBuff);
// Generate the headers to use for '=' packets. These have a changeable part
// and a non-changeable part.
//
hdr = "{\"code\":\"%c\",\"pseq\":%%u,";
snprintf(hBuff, sizeof(hBuff), hdr, XROOTD_MON_MAPIDNT);
idntHdr0 = strdup(hBuff);
hdr = "\"stod\":%u,\"sid\":%s,%s}";
n = snprintf(hBuff, sizeof(hBuff), hdr, ntohl(startTime), kySID, SidJSON[3]);
idntHdr1 = strdup(hBuff);
idntHsz1 = n+1;
// Generate the header of plugin output
//
hdr = "{\"code\":\"%c\",\"pseq\":$12,\"stod\":%u,\"sid\":%s%s%s,"
"\"gs\":{\"type\":\"%c\",\"tbeg\":$123456789,\"tend\":$123456789}}\n";
// Format the header (we are gauranteed to have at least 1024 bytes here)
//
n = snprintf(buff, blen, hdr, XROOTD_MON_MAPGSTA, ntohl(startTime),
kySID, plug1, plug2, gs.Type);
// Return all of the substitution addresses
//
hInfo.pseq = index(buff, '$');
hInfo.tbeg = index(hInfo.pseq+1, '$');
hInfo.tend = index(hInfo.tbeg+1, '$');
// Return the length
//
return n;
}
/******************************************************************************/
/* I d e n t */
/******************************************************************************/
void XrdXrootdGSReal::Ident()
{
struct iovec iov[2];
char buff[40];
uint32_t psq;
// If identification suppressed, then just return
//
if (!idntHdr0 || !udpDest) return;
// Generate a new packet sequence number
//
gMutex.Lock();
if (pSeqID >= 999) pSeqID = 0;
else pSeqID++;
psq = pSeqID;
gMutex.UnLock();
// Create header and iovec to send the header
//
iov[0].iov_base = buff;
iov[0].iov_len = snprintf(buff, sizeof(buff), idntHdr0, psq);
iov[1].iov_base = idntHdr1;
iov[1].iov_len = idntHsz1;
udpDest->Send(iov, 2);
}
/******************************************************************************/
/* I n s e r t */
/******************************************************************************/
bool XrdXrootdGSReal::Insert(const char *data, int dlen)
{
// Validate the length and message
//
if (dlen < 8 || dlen > XrdXrootdGStream::MaxDataLen
|| !data || data[dlen-1]) return false;
// Reserve the storage and copy the message. It always will end with a newline
//
gMutex.Lock();
Expel(dlen);
memcpy(udpBNext, data, dlen-1);
udpBNext[dlen-1] = '\n';
// Timestamp the record and aAdjust buffer pointers
//
tEnd = time(0);
if (udpBNext == udpBFirst) tBeg = tEnd;
udpBNext += dlen;
// All done
//
gMutex.UnLock();
return true;
}
/******************************************************************************/
bool XrdXrootdGSReal::Insert(int dlen)
{
XrdSysMutexHelper gHelp(gMutex);
// Make sure space is reserved
//
if (!rsvbytes) return false;
// We are now sure that the recursive lock is held twice by this thread. So,
// make it a unitary lock so it gets fully unlocked upon rturn.
//
gMutex.UnLock();
// Check for cancellation
//
if (!dlen)
{rsvbytes = 0;
return true;
}
// Length, it must >= 8 and <= reserved amount and the data must end with a 0.
//
if (dlen > rsvbytes || dlen < 8 || *(udpBNext+dlen-1))
{rsvbytes = 0;
return false;
}
// Adjust the buffer space and time stamp the record
//
tEnd = time(0);
if (udpBNext == udpBFirst) tBeg = tEnd;
udpBNext += dlen;
*(udpBNext-1) = '\n';
rsvbytes = 0;
// All done
return true;
}
/******************************************************************************/
/* R e s e r v e */
/******************************************************************************/
char *XrdXrootdGSReal::Reserve(int dlen)
{
// Validate the length
//
if (dlen < 8 || dlen > XrdXrootdGStream::MaxDataLen) return 0;
// Make sure there is no reserve outstanding
//
gMutex.Lock();
if (rsvbytes)
{gMutex.UnLock();
return 0;
}
// Return the allocated the space but keep the lock until Insert() is called.
//
rsvbytes = dlen;
Expel(dlen);
return udpBNext;
}
/******************************************************************************/
/* S e t A u t o F l u s h */
/******************************************************************************/
int XrdXrootdGSReal::SetAutoFlush(int afsec)
{
XrdSysMutexHelper gHelp(gMutex);
// Save the current settting and establish the new one and relaunch
//
int afNow = afTime;
afTime = (afsec > 0 ? afsec : 0);
AutoFlush();
// All done
//
return afNow;
}
/******************************************************************************/
/* S p a c e */
/******************************************************************************/
int XrdXrootdGSReal::Space()
{
XrdSysMutexHelper gHelp(gMutex);
// Return amount of space left
//
return udpBEnd - udpBNext;
}
eDest
static XrdSysError eDest(0,"crypto_")
XrdNetMsg.hh
XrdScheduler.hh
XrdSysPlatform.hh
XrdXrootdGSReal.hh
XROOTD_MON_PIDSHFT
const long long XROOTD_MON_PIDSHFT
Definition XrdXrootdMonData.hh:159
XrdXrootdMonGS::tEnd
int tEnd
Definition XrdXrootdMonData.hh:83
XROOTD_MON_MAPGSTA
const kXR_char XROOTD_MON_MAPGSTA
Definition XrdXrootdMonData.hh:106
XROOTD_MON_MAPINFO
const kXR_char XROOTD_MON_MAPINFO
Definition XrdXrootdMonData.hh:107
XROOTD_MON_MAPIDNT
const kXR_char XROOTD_MON_MAPIDNT
Definition XrdXrootdMonData.hh:103
XrdXrootdMonHeader::stod
kXR_int32 stod
Definition XrdXrootdMonData.hh:43
XROOTD_MON_MAPPATH
const kXR_char XROOTD_MON_MAPPATH
Definition XrdXrootdMonData.hh:104
XrdXrootdMonHeader::plen
kXR_unt16 plen
Definition XrdXrootdMonData.hh:42
XrdXrootdMonHeader::pseq
kXR_char pseq
Definition XrdXrootdMonData.hh:41
XrdXrootdMonHeader::code
kXR_char code
Definition XrdXrootdMonData.hh:40
XrdXrootdMonGS::tBeg
int tBeg
Definition XrdXrootdMonData.hh:82
XrdXrootdMonGS::hdr
XrdXrootdMonHeader hdr
Definition XrdXrootdMonData.hh:81
XrdXrootdMonGS::sID
kXR_int64 sID
Definition XrdXrootdMonData.hh:84
XrdXrootdMonGS
Definition XrdXrootdMonData.hh:81
XrdJob
Definition XrdJob.hh:43
XrdJob::XrdJob
XrdJob(const char *desc="")
Definition XrdJob.hh:51
XrdNetMsg
Definition XrdNetMsg.hh:50
XrdScheduler
Definition XrdScheduler.hh:47
XrdSysError
Definition XrdSysError.hh:90
XrdSysMutexHelper
Definition XrdSysPthread.hh:263
XrdXrootdGSReal::GetDictID
uint32_t GetDictID(const char *text, bool isPath=false)
Definition XrdXrootdGSReal.cc:251
XrdXrootdGSReal::Reserve
char * Reserve(int dlen)
Definition XrdXrootdGSReal.cc:559
XrdXrootdGSReal::hdrNone
static const int hdrNone
Format as JSON info.
Definition XrdXrootdGSReal.hh:86
XrdXrootdGSReal::GSParms::Opt
char Opt
Options.
Definition XrdXrootdGSReal.hh:101
XrdXrootdGSReal::GSParms::Type
kXR_char Type
the specific G-Stream identifier
Definition XrdXrootdGSReal.hh:100
XrdXrootdGSReal::GSParms::dest
const char * dest
Destination for records.
Definition XrdXrootdGSReal.hh:96
XrdXrootdGSReal::hdrInst
static const int hdrInst
Include site, host, port, inst.
Definition XrdXrootdGSReal.hh:90
XrdXrootdGSReal::SetAutoFlush
int SetAutoFlush(int afsec)
Definition XrdXrootdGSReal.cc:584
XrdXrootdGSReal::fmtBin
static const int fmtBin
Do not include info.
Definition XrdXrootdGSReal.hh:82
XrdXrootdGSReal::XrdXrootdGSReal
XrdXrootdGSReal(const GSParms &gsParms, bool &aOK)
Definition XrdXrootdGSReal.cc:64
XrdXrootdGSReal::fmtJson
static const int fmtJson
Format as CGI info.
Definition XrdXrootdGSReal.hh:84
XrdXrootdGSReal::GSParms::maxL
int maxL
Maximum packet length (default 32K).
Definition XrdXrootdGSReal.hh:98
XrdXrootdGSReal::hdrSite
static const int hdrSite
Include site.
Definition XrdXrootdGSReal.hh:88
XrdXrootdGSReal::GSParms::flsT
int flsT
Flush time (default from monitor).
Definition XrdXrootdGSReal.hh:99
XrdXrootdGSReal::GSParms::pin
const char * pin
the plugin name.
Definition XrdXrootdGSReal.hh:95
XrdXrootdGSReal::hdrHost
static const int hdrHost
Include site, host.
Definition XrdXrootdGSReal.hh:89
XrdXrootdGSReal::GSParms::Fmt
char Fmt
How to handle the records.
Definition XrdXrootdGSReal.hh:102
XrdXrootdGSReal::optNoID
static const int optNoID
Don't send ident records.
Definition XrdXrootdGSReal.hh:93
XrdXrootdGSReal::Flush
void Flush()
Definition XrdXrootdGSReal.cc:241
XrdXrootdGSReal::Space
int Space()
Definition XrdXrootdGSReal.cc:603
XrdXrootdGSReal::Insert
bool Insert(const char *data, int dlen)
Definition XrdXrootdGSReal.cc:486
XrdXrootdGSReal::GSParms::Mode
int Mode
the monitor type for send routing.
Definition XrdXrootdGSReal.hh:97
XrdXrootdGSReal::Ident
void Ident()
Definition XrdXrootdGSReal.cc:455
XrdXrootdGSReal::hdrNorm
static const int hdrNorm
Include standard header.
Definition XrdXrootdGSReal.hh:87
XrdXrootdGSReal::DoIt
void DoIt()
Definition XrdXrootdGSReal.cc:173
XrdXrootdGSReal::GSParms::Hdr
char Hdr
Hdr type.
Definition XrdXrootdGSReal.hh:103
XrdXrootdGSReal::fmtCgi
static const int fmtCgi
Format as binary info.
Definition XrdXrootdGSReal.hh:83
XrdXrootdGSReal::HasHdr
bool HasHdr()
Definition XrdXrootdGSReal.cc:295
XrdXrootdGSReal::hdrFull
static const int hdrFull
Include site, host, port, inst, pgm.
Definition XrdXrootdGSReal.hh:91
XrdXrootdGSReal::GSParms
Definition XrdXrootdGSReal.hh:95
XrdXrootdGStream::XrdXrootdGStream
XrdXrootdGStream(XrdXrootdGSReal &gsRef)
Definition XrdXrootdGStream.hh:158
XrdXrootdGStream::MaxDataLen
static const int MaxDataLen
The larest amount of data that can be inserted in a single call to GStream.
Definition XrdXrootdGStream.hh:150
XrdXrootdMonitor::Hello::Hello
Hello(const char *dest, char mode)
Definition XrdXrootdMonitor.cc:229
XrdXrootdMonitor::Flushing
static int Flushing()
Definition XrdXrootdMonitor.hh:124
XrdXrootdMonitor::Send
static int Send(int mmode, void *buff, int size, bool setseq=true)
Definition XrdXrootdMonitor.cc:1198
XrdXrootdMonitor::GetDictID
static kXR_unt32 GetDictID(bool hbo=false)
Definition XrdXrootdMonitor.cc:816
XrdXrootdMonInfo
Definition XrdXrootdGSReal.cc:46
XrdXrootdMonInfo::Sched
XrdScheduler * Sched
Definition XrdXrootdMonFile.cc:47
XrdXrootdMonInfo::mySID
long long mySID
Definition XrdXrootdMonFile.cc:49
XrdXrootdMonInfo::eDest
XrdSysError * eDest
Definition XrdXrootdMonFile.cc:48
XrdXrootdMonInfo::startTime
int startTime
Definition XrdXrootdMonFile.cc:50
XrdXrootdMonInfo::SidJSON
char * SidJSON[4]
Definition XrdXrootdMonitor.cc:120
XrdXrootdMonInfo::SidCGI
char * SidCGI[4]
Definition XrdXrootdMonitor.cc:118
XrdXrootdMonInfo::monHost
char * monHost
Definition XrdXrootdMonitor.cc:111
XrdXrootdMonInfo::kySID
char * kySID
Definition XrdXrootdMonitor.cc:112
iov
Definition XrdOucIOVec.hh:65