/*------------------------------------------------------------------------------
* function: AttrProj::ReadWholeRec
* Read an entire record (not its projections).
*/
DevStatus
AttrProj::ReadWholeRec(RecId recId, Vector &vector)
{
DO_DEBUG(printf("AttrProj::ReadWholeRec()\n"));
DevStatus result = StatusOk;
_tDataP->InitGetRecs(recId, recId);
int dataSize;
int numRecs;
if (!_tDataP->GetRecs(_recBuf, _recBufSize, recId, numRecs, dataSize))
{
result = StatusFailed;
}
else
{
AttrList * attrListP = _tDataP->GetAttrList();
int attrNum = 0;
attrListP->InitIterator();
while (attrListP->More())
{
AttrInfo *attrInfoP = attrListP->Next();
vector.value[attrNum] = AttrToDouble(attrInfoP->type,
_recBuf + attrInfoP->offset);
attrNum++;
}
attrListP->DoneIterator();
}
return result;
}
AttrList USBAddr::getAttrList() const
{
AttrList attrs;
if ( !bus->text().isEmpty() )
attrs.insert("bus", bus->text());
if ( !port->text().isEmpty() )
attrs.insert("port", port->text());
return attrs;
}
float ClassAdCollection::GetClassAdRank(ClassAd* Ad, const MyString& RankExpr)
{
if (RankExpr.Length()==0) return 0.0;
AttrList RankingAd;
RankingAd.AssignExpr( ATTR_RANK, RankExpr.Value() );
float Rank;
if (!RankingAd.EvalFloat(ATTR_RANK,Ad,Rank)) Rank=0.0;
return Rank;
}
AttrList CCIDAddr::getAttrList() const
{
AttrList attrs;
if ( !bus->text().isEmpty() )
attrs.insert("bus", bus->text());
if ( !slot->text().isEmpty() )
attrs.insert("slot", slot->text());
return attrs;
}
AttrList CCWAddr::getAttrList() const
{
AttrList attrs;
if ( !machine->text().isEmpty() )
attrs.insert("machine", machine->text());
if ( !cssid->text().isEmpty() )
attrs.insert("cssid", cssid->text());
attrs.insert("ssid", ssid->text());
if ( !devno->text().isEmpty() )
attrs.insert("devno", devno->text());
return attrs;
}
// [1][a][1]{[1][c][4]}
// a b c d b
//
// a - name length
// b - attr count
// c - nth attr name length
// d - nth attr type id
void PkgTypeEncoder::Encode(StrView name, const AttrList& attrs) {
EncodeString(name.Data(), name.Len());
EncodeByte(attrs.size());
for (const sym::Attr& attr : attrs) {
EncodeString(attr.name.Data(), attr.name.Len());
EncodeType(attr.type);
}
}
/*------------------------------------------------------------------------------
* function: AttrProj::ReadRec
* Read a record from the data source, and project it onto the attribute
* combinations corresponding to this object.
*/
DevStatus
AttrProj::ReadRec(RecId recId, VectorArray &vecArray)
{
DO_DEBUG(printf("AttrProj::ReadRec(%d)\n", (int) recId));
int dataSize;
int numRecs;
DevStatus result = StatusOk;
TData::TDHandle handle = _tDataP->InitGetRecs(recId, recId);
if (!_tDataP->GetRecs(handle, _recBuf, _recBufSize,
recId, numRecs, dataSize))
{
result = StatusFailed;
}
else
{
AttrList * attrListP = _tDataP->GetAttrList();
int projNum = 0;
Projection * projP = _projList.GetFirstProj();
while (projP != NULL)
{
Vector * vectorP = vecArray.GetVector(projNum);
int projAttrNum;
for (projAttrNum = 0; projAttrNum < projP->attrCount;
projAttrNum++)
{
int attrNum = projP->attrList[projAttrNum];
AttrInfo * attrInfoP = attrListP->Get(attrNum);
vectorP->value[projAttrNum] = AttrToDouble(attrInfoP->type,
_recBuf + attrInfoP->offset);
}
projP = _projList.GetNextProj();
projNum++;
}
}
_tDataP->DoneGetRecs(handle);
return result;
}
/*------------------------------------------------------------------------------
* function: AttrProj::GetWholeRecSize
* Returns information about the size of data that will be produced when
* an entire record (not its projections) is read.
*/
DevStatus
AttrProj::GetWholeRecSize(int &attrCount, int &recSize)
{
DO_DEBUG(printf("AttrProj::GetWholeRecSize()\n"));
DevStatus result = StatusOk;
attrCount = 0;
recSize = 0;
AttrList *attrListP = _tDataP->GetAttrList();
attrListP->InitIterator();
while (attrListP->More())
{
AttrInfo *attrInfoP = attrListP->Next();
attrCount++;
recSize += sizeof(VECTOR_TYPE);
}
attrListP->DoneIterator();
return result;
}
AttrList Load::attrList()
{
AttrList l;
l.push_back("filename");
return l;
}
// Read the history from a single file and print it out.
static void readHistoryFromFile(char *JobHistoryFileName, char* constraint, ExprTree *constraintExpr)
{
int EndFlag = 0;
int ErrorFlag = 0;
int EmptyFlag = 0;
AttrList *ad = NULL;
long offset = 0;
bool BOF = false; // Beginning Of File
MyString buf;
FILE* LogFile=safe_fopen_wrapper(JobHistoryFileName,"r");
if (!LogFile) {
fprintf(stderr,"History file (%s) not found or empty.\n", JobHistoryFileName);
exit(1);
}
// In case of rotated history files, check if we have already reached the number of
// matches specified by the user before reading the next file
if (specifiedMatch != 0) {
if (matchCount == specifiedMatch) { // Already found n number of matches, cleanup
fclose(LogFile);
return;
}
}
if (backwards) {
offset = findLastDelimiter(LogFile, JobHistoryFileName);
}
while(!EndFlag) {
if (backwards) { // Read history file backwards
if (BOF) { // If reached beginning of file
break;
}
offset = findPrevDelimiter(LogFile, JobHistoryFileName, offset);
if (offset == -1) { // Unable to match constraint
break;
} else if (offset != 0) {
fseek(LogFile, offset, SEEK_SET);
buf.readLine(LogFile); // Read one line to skip delimiter and adjust to actual offset of ad
} else { // Offset set to 0
BOF = true;
fseek(LogFile, offset, SEEK_SET);
}
}
if( !( ad=new AttrList(LogFile,"***", EndFlag, ErrorFlag, EmptyFlag) ) ){
fprintf( stderr, "Error: Out of memory\n" );
exit( 1 );
}
if( ErrorFlag ) {
printf( "\t*** Warning: Bad history file; skipping malformed ad(s)\n" );
ErrorFlag=0;
if(ad) {
delete ad;
ad = NULL;
}
continue;
}
if( EmptyFlag ) {
EmptyFlag=0;
if(ad) {
delete ad;
ad = NULL;
}
continue;
}
if (!constraint || EvalBool(ad, constraintExpr)) {
if (longformat) {
ad->fPrint(stdout); printf("\n");
} else {
if (customFormat) {
mask.display(stdout, ad);
} else {
displayJobShort(ad);
}
}
matchCount++; // if control reached here, match has occured
if (specifiedMatch != 0) { // User specified a match number
if (matchCount == specifiedMatch) { // Found n number of matches, cleanup
if (ad) {
delete ad;
ad = NULL;
}
fclose(LogFile);
return;
}
}
}
if(ad) {
delete ad;
ad = NULL;
}
}
fclose(LogFile);
return;
}
AttrList::AttrList (PropertyName n) : (n) {
value = nil;
type = nil;
}
boolean AttrList::FindAttr (register PropertyDef& p) {
register AttrList* a;
for (a = (AttrList*)next; a != this; a = (AttrList*)a->next) {
if (a->name == p.name) {
p.type = a->type;
p.value = a->value;
return true;
}
}
return false;
}
/*
* class DirList
*/
DirList::DirList () {
info = nil;
}
DirList::DirList (PropertyName n) : (n) {
info = new PropDir;
}
boolean DirList::FindSubDir (PropertyName n, PropDir*& subdir) {
register DirList* d;
for (d = (DirList*)next; d != this; d = (DirList*)d->next) {
if (d->name == n) {
subdir = d->info;
return true;
}
}
return false;
}
DirList::~DirList () {
delete info;
}
/*
* class PropDir
*/
PropDir::PropDir () {
parent = nil;
attrs = new AttrList;
dirs = new DirList;
vattrs = new AttrList;
vdirs = new DirList;
}
PropDir::~PropDir () {
dirs->DeleteAll();
delete dirs;
vdirs->DeleteAll();
delete vdirs;
attrs->DeleteAll();
delete attrs;
vattrs->DeleteAll();
delete vattrs;
}
PropDir* PropDir::MakeDirs (const char*& name) {
register const char* p;
PropDir* dir;
DirList* cur, * sub;
PropertyName n;
int c;
dir = this;
c = '.';
for (p = name; *p != '\0'; p++) {
if (*p == '.' || *p == '*') {
if (p > name) {
n = nameTable->Id(name, p - name);
cur = (c == '*') ? dir->vdirs : dir->dirs;
if (!cur->FindSubDir(n, dir)) {
sub = new DirList(n);
sub->info->parent = dir;
cur->Append(sub);
dir = sub->info;
}
}
c = *p;
name = p + 1;
}
}
return dir;
}
/*
* class PropPath
*/
PropPath::PropPath () {
top = &element[0];
next = nil;
prev = nil;
}
/*
* class PropertySheet
*/
PropertySheet::PropertySheet () {
cur = new PropDir;
head = new PropPath;
tail = head;
head->element[0].dir = cur;
head->element[0].sibling = false;
if (propvalues == nil) {
propvalues = new StringPool;
}
}
PropertySheet::~PropertySheet () {
register PropPath* p, * pnext;
delete cur;
for (p = head; p != nil; p = pnext) {
pnext = p->next;
delete p;
}
}
boolean PropertySheet::Get (PropertyDef& prop) {
register PropPath* p;
register PropPathElement* i;
/* look for instance.attr */
p = tail;
i = tail->top;
if (i->dir->attrs->FindAttr(prop)) {
return true;
}
/* look for class.attr (if prev path element is class for instance) */
if (i->sibling) {
/* prev path element is class -- look for class.attr */
--i;
if (i < &p->element[0]) {
i = p->prev->top;
}
if (i->dir->attrs->FindAttr(prop)) {
return true;
}
}
/* look for path*attr */
for (p = tail; p != nil; p = p->prev) {
for (i = p->top; i >= &p->element[0]; i--) {
if (i->dir->vattrs->FindAttr(prop)) {
return true;
}
}
}
prop.value = nil;
return false;
}
/*
* Special lookup under current directory for .attr or *attr.
*/
boolean PropertySheet::GetLocal (PropDir* dir, PropertyDef& prop) {
if (dir->attrs->FindAttr(prop) || dir->vattrs->FindAttr(prop)) {
return true;
}
prop.value = nil;
return false;
}
/*
* Add an empty directory to the property sheet.
*/
PropDir* PropertySheet::MakeDir (const char* path) {
const char* name = path;
PropDir* dir = cur;
DirList* d = (name > path && *(name-1) == '*') ? dir->vdirs : dir->dirs;
PropertyName n = nameTable->Id(name);
if (!d->FindSubDir(n, dir)) {
DirList* sub = new DirList(n);
sub->info->parent = dir;
d->Append(sub);
dir = sub->info;
}
return dir;
}
/*
* Put an attribute in the property sheet, starting the path search
* at a given directory (typically the root). If the name is already
* defined and the "override" parameter is false, then do nothing.
*/
void PropertySheet::DoPut (
PropDir* root, const char* path, const char* value, const char* type,
boolean override
) {
const char* name = path;
boolean newvalue = override;
PropDir* dir = root->MakeDirs(name);
AttrList* alist =
(name > path && *(name-1) == '*') ? dir->vattrs : dir->attrs;
PropertyName n = nameTable->Id(name);
register AttrList* a = (AttrList*)alist->Find(n);
if (a == nil) {
a = new AttrList(n);
alist->Append(a);
newvalue = true;
}
if (newvalue) {
register const char* v;
for (v = value; isspace(*v); v++);
a->value = propvalues->Append(v, (int)(strlen(v) + 1));
a->type = type;
}
}
/*
* Look up the path for a subdirectory matching the given name.
*/
PropDir* PropertySheet::Find (PropertyName name) {
register PropPath* p;
register PropPathElement* e;
PropDir* dir;
dir = nil;
/* look for path.name */
if (tail->top->dir->dirs->FindSubDir(name, dir)) {
return dir;
}
/* look for path*name */
for (p = tail; p != nil; p = p->prev) {
for (e = p->top; e >= &p->element[0]; e--) {
if (e->dir->vdirs->FindSubDir(name, dir)) {
return dir;
}
}
}
return nil;
}
void PropertySheet::Push (PropDir* dir, boolean b) {
register PropPath* p;
register PropPathElement* e;
p = tail;
e = p->top + 1;
if (e >= &p->element[pathClusterSize]) {
p = new PropPath;
p->prev = tail;
tail->next = p;
tail = p;
e = p->top;
} else {
p->top = e;
}
e->dir = dir;
e->sibling = b;
}
void PropertySheet::Pop () {
register PropPath* p = tail;
if (p == nil) {
/* ignore underflow */
} else if (p->top > &p->element[0]) {
p->top -= 1;
} else {
tail = p->prev;
tail->next = nil;
delete p;
}
}
PropDir* PropertySheet::Root () {
return cur;
}
static int line; /* for error handling */
/*
* Load a single property from a string containing
* the name and value, terminated by either a newline or null.
*/
class PropSheetBuf {
public:
PropSheetBuf(int);
~PropSheetBuf();
char* data() { return _data; }
private:
char* _data;
char _smallbuf[256];
};
PropSheetBuf::PropSheetBuf(int n) {
_data = (n < sizeof(_smallbuf)) ? _smallbuf : new char[n + 1];
}
PropSheetBuf::~PropSheetBuf() {
if (_data != _smallbuf) {
delete _data;
}
}
void PropertySheet::LoadProperty (const char* s) {
register const char* src;
register char* dst;
const char* value;
for (src = s; *src == ' ' || *src == '\t'; src++);
if (*src == '#' || *src == '\n' || *src == '\0') {
return;
}
PropSheetBuf buf(strlen(src));
dst = buf.data();
value = nil;
for (; *src != '\n' && *src != '\0'; src++) {
if (*src == '\\') {
++src;
if (*src == 'n') {
*dst++ = '\n';
} else if (*src == '\n') {
++line;
} else {
*dst++ = *src;
}
} else if (value == nil && *src == ':') {
if (dst == buf.data()) {
fprintf(stderr, "%d: empty path\n", line);
return;
}
*dst++ = '\0';
value = dst;
} else {
*dst++ = *src;
}
}
*dst = '\0';
if (value == nil) {
fprintf(stderr, "%d: missing value for %s\n", line, buf.data());
return;
}
PutLower(buf.data(), value);
}
/*
* Parse property sheet information from a string.
*/
void PropertySheet::LoadList (const char* data) {
register const char* p, * start;
start = data;
for (p = strchr(data, '\n'); p != nil; p = strchr(p+1, '\n')) {
if (p > start && *(p-1) != '\\') {
LoadProperty(start);
}
start = p+1;
}
}
/*
* Read a property sheet from a file (e.g., Xdefaults).
*/
boolean PropertySheet::LoadFile (const char* filename) {
FILE* f;
char buf[4096];
register int i;
if (filename == nil) {
f = stdin;
} else {
f = fopen(filename, "r");
if (f == nil) {
return false;
}
}
line = 0;
i = 0;
while (fgets(&buf[i], (int)(sizeof(buf) - i), f) != nil) {
i = strlen(buf);
if (buf[i-1] == '\n' && buf[i-2] != '\\') {
LoadProperty(buf);
i = 0;
} else {
if (i == sizeof(buf)) {
fprintf(stderr, "%s: %d: line too long\n", filename, line);
return true;
}
}
}
return true;
}
QuillErrCode
HistorySnapshot::printResults(SQLQuery *queryhor,
SQLQuery *queryver,
bool longformat, bool fileformat,
bool custForm,
AttrListPrintMask *pmask,
const char *constraint /* = "" */) {
AttrList *ad = 0;
QuillErrCode st = QUILL_SUCCESS;
// initialize index variables
off_t offset = 0, last_line = 0;
cur_historyads_hor_index = 0;
cur_historyads_ver_index = 0;
if (!longformat && !custForm) {
short_header();
}
ExprTree *tree = NULL;
if (constraint) {
ParseClassAdRvalExpr(constraint, tree);
}
while(1) {
st = getNextAd_Hor(ad, queryhor);
if(st != QUILL_SUCCESS)
break;
if (longformat || constraint) {
st = getNextAd_Ver(ad, queryver);
if (constraint && EvalBool(ad, tree) == FALSE) {
continue;
}
// in the case of vertical, we dont want to quit if we run
// out of tuples because 1) we want to display whats in the ad
// and 2) the horizontal cursor will correctly determine when
// to stop - this is because in all cases, we only pull out those
// tuples from vertical which join with a horizontal tuple
if(st != QUILL_SUCCESS && st != DONE_HISTORY_VER_CURSOR)
break;
if (fileformat) { // Print out the job ads in history file format, i.e., print the *** delimiters
MyString owner, ad_str, temp;
int compl_date;
ad->sPrint(ad_str);
if (!ad->LookupString(ATTR_OWNER, owner))
owner = "NULL";
if (!ad->LookupInteger(ATTR_COMPLETION_DATE, compl_date))
compl_date = 0;
temp.formatstr("*** Offset = %ld ClusterId = %d ProcId = %d Owner = \"%s\" CompletionDate = %d\n",
offset - last_line, curClusterId_hor, curProcId_hor, owner.Value(), compl_date);
offset += ad_str.Length() + temp.Length();
last_line = temp.Length();
fprintf(stdout, "%s", ad_str.Value());
fprintf(stdout, "%s", temp.Value());
} else if (longformat) {
ad->fPrint(stdout);
printf("\n");
}
}
if (!longformat) {
if (custForm == true) {
ASSERT(pmask != NULL);
pmask->display(stdout, ad);
} else {
displayJobShort(ad);
}
}
}
if(ad != NULL) {
delete ad;
ad = NULL;
}
if(st == FAILURE_QUERY_HISTORYADS_HOR || st == FAILURE_QUERY_HISTORYADS_VER)
return st;
return QUILL_SUCCESS;
}
/*------------------------------------------------------------------------------
* function: AttrProj::ParseProjection
* Parse the attribute projection file and build up the corresponding
* data structures.
*/
DevStatus
AttrProj::ParseProjection(char *attrProjFile)
{
DO_DEBUG(printf("AttrProj::ParseProjection()\n"));
DevStatus result = StatusOk;
FILE * file = fopen(attrProjFile, "r");
if (file == NULL)
{
fprintf(stderr, "Can't open attribute projection file\n");
result = StatusFailed;
}
else
{
const int bufSize = 4096;
char buf[bufSize];
char separators[] = " \t";
/* Get each line in the attribute projection file. */
while (fgets(buf, bufSize, file) != NULL)
{
DOASSERT(buf[strlen(buf)-1] == '\n',
"Projection file line too long");
/* TEMPTEMP -- we should look for some kind of comment char. */
StripTrailingNewline(buf);
DO_DEBUG(printf("%s\n", buf));
Projection projection;
char * token = strtok(buf, separators);
if (token == NULL) continue;
projection.attrCount = atoi(token);
DO_DEBUG(printf("projection.attrCount = %d\n",
projection.attrCount));
projection.attrList = new int[projection.attrCount];
AttrList * attrListP = _tDataP->GetAttrList();
int attrCount = attrListP->NumAttrs();
int projAttrNum = 0;
/* Find each attribute specified for this projection. */
while ((token = strtok(NULL, separators)) != NULL)
{
projection.attrList[projAttrNum] = illegalAttr;
DO_DEBUG(printf(" token = %s", token));
int attrNum;
/* Now find the attribute in the TData corresponding to
* the name specified in the projection. */
for (attrNum = 0; attrNum < attrCount; attrNum++)
{
AttrInfo * attrInfoP = attrListP->Get(attrNum);
if (!strcmp(token, attrInfoP->name))
{
DO_DEBUG(printf(" attrNum = %d\n", attrNum));
projection.attrList[projAttrNum] = attrNum;
break;
}
}
DOASSERT(projection.attrList[projAttrNum] != illegalAttr,
"Illegal attribute name in attribute projection file");
projAttrNum++;
}
DOASSERT(projAttrNum == projection.attrCount,
"Incorrect number of attributes in projection file");
_projList.AddProjection(projection);
}
fclose(file);
}
return result;
}