int edwSubmitPositionInQueue(struct sqlConnection *conn, char *url, unsigned *retJobId)
/* Return position of our URL in submission queue. Optionally return id in edwSubmitJob
* table of job. */
{
char query[256];
sqlSafef(query, sizeof(query), "select id,commandLine from edwSubmitJob where startTime = 0");
struct sqlResult *sr = sqlGetResult(conn, query);
char **row;
int aheadOfUs = -1;
int pos = 0;
unsigned jobId = 0;
while ((row = sqlNextRow(sr)) != NULL)
{
jobId = sqlUnsigned(row[0]);
char *line = row[1];
char *edwSubmit = nextQuotedWord(&line);
char *lineUrl = nextQuotedWord(&line);
if (sameOk(edwSubmit, "edwSubmit") && sameOk(url, lineUrl))
{
aheadOfUs = pos;
break;
}
++pos;
}
sqlFreeResult(&sr);
if (retJobId != NULL)
*retJobId = jobId;
return aheadOfUs;
}
static boolean chromGraphRecognizer(struct customFactory *fac,
struct customPp *cpp, char *type,
struct customTrack *track)
/* Return TRUE if looks like we're handling a chromGraph track */
{
return sameOk(type, fac->name);
}
static knetFile *kuOpen(const char *filename, const char *mode)
/* Open the given filename with mode which must be "r". */
{
#ifdef USE_HTS
if (!(sameOk((char *)mode, "r") || sameOk((char *)mode, "rb")))
errAbort("mode passed to kuOpen must be 'r' or 'rb' not '%s'", mode);
#else
if (!sameOk((char *)mode, "r"))
errAbort("mode passed to kuOpen must be 'r' not '%s'", mode);
#endif
struct udcFile *udcf = udcFileMayOpen((char *)filename, udcCacheDir);
if (udcf == NULL)
return NULL;
knetFile *kf = NULL;
AllocVar(kf);
kf->udcf = udcf;
verbose(2, "kuOpen: returning %lu\n", (unsigned long)(kf->udcf));
return kf;
}
void flushResults()
/* Send msg to hub to flush results file */
{
char results[PATH_LEN];
getResultsFile(results);
char command[2*PATH_LEN];
safef(command, sizeof(command), "flushResults %s %s", getUser(), results);
char *result = hubCommandGetReciept(command);
if (result == NULL)
errAbort("result == NULL");
if (sameOk(result, "-3"))
errAbort("User not found.");
if (sameOk(result, "-2"))
errAbort("Batch not found.");
if (sameOk(result, "-1"))
warn("Flushed results. Some jobs are still queued or running.");
if (sameOk(result, "0"))
printf("Flushed results.\n");
freez(&result);
}
void freeBatch()
/* Send msg to hub to reset done and crashed counts on batch */
{
char results[PATH_LEN];
getResultsFile(results);
char command[2*PATH_LEN];
safef(command, sizeof(command), "freeBatch %s %s", getUser(), results);
char *result = hubCommandGetReciept(command);
if (result == NULL)
errAbort("result == NULL");
if (sameOk(result, "-3"))
errAbort("User not found.");
if (sameOk(result, "-2"))
errAbort("Batch not found.");
if (sameOk(result, "-1"))
warn("Unable to free batch. Jobs are queued or running.");
if (sameOk(result, "0"))
printf("Batch freed.\n");
freez(&result);
}
void metaNodeAddVar(struct metaNode *node, char *var, char *val)
/* Add var to node - but only if it is not already present at same value at a higher level */
{
if (val == NULL)
return;
if (node->parent != NULL && sameOk(metaVal(node->parent, var), val))
return; /* Already in parent, we are fine. */
if (metaLocalVal(node, var))
errAbort("Redefining %s.%s\n", node->name, var);
struct mdbVar *v = mdbVarNew(var, val);
slAddHead(&node->vars, v);
}
void bigDrawWarning(struct track *tg, int seqStart, int seqEnd, struct hvGfx *hvg,
int xOff, int yOff, int width, MgFont *font, Color color,
enum trackVisibility vis)
/* Draw the network error message */
{
char message[1024];
Color yellow = hvGfxFindRgb(hvg, &undefinedYellowColor);
char *errMsg = bigWarnReformat(tg->networkErrMsg);
char *nl = errMsg;
int sl = strlen(errMsg);
// in some cases, cannot use tg-> values, so recalc local equivalents.
int heightPer = tl.fontHeight; /* Height per item line minus border. */
int lineHeight = heightPer+4; /* Height per item line including border. */
if (lineHeight > tg->height)
lineHeight = tg->height;
int n = bigWarnNumLines(errMsg); /* Lines of warning text */
int m = tg->height / lineHeight; /* Lines of text space available */
if (m < 1)
m = 1;
// make yellow background to draw user's attention to the err msg
if (!sameOk(parentContainerType(tg), "multiWig")) // unless multiwig has already done it.
hvGfxBox(hvg, xOff, yOff, width, tg->height, yellow);
// leading blank lines if any
int bl = (m-n)/2;
int i;
for(i=0;i<bl;++i)
yOff += lineHeight;
int l = 0;
while (TRUE)
{
char *msg = nl;
nl = strchr(nl,'\n');
if (nl)
nl[0] = 0;
if (nl || ((sl > 0) && (errMsg[sl-1]!='\n')))
{
safef(message, sizeof(message), "%s", msg);
hvGfxTextCentered(hvg, xOff, yOff, width, lineHeight, MG_BLACK, font, message);
yOff += lineHeight;
++l;
if (l > n)
break;
if (l > m)
break;
}
if (!nl)
break;
++nl;
}
freeMem(errMsg);
}
int main(int argc, char *argv[])
/* Process command line. */
{
oldVars = hashNew(10);
cgiSpoof(&argc, argv);
/* org has precedence over db when changeInfo='orgChange' */
orgChange = sameOk(cgiOptionalString("changeInfo"),"orgChange");
if (orgChange)
{
cgiVarSet("db", hDefaultDbForGenome(cgiOptionalString("org")));
}
htmlSetBackground(hBackgroundImage());
cartEmptyShell(doMiddle, hUserCookie(), excludeVars, oldVars);
return 0;
}
void doMiddle(struct cart *theCart)
/* Write header and body of html page. */
{
char *userSeq;
char *db, *organism;
boolean clearUserSeq = cgiBoolean("Clear");
cart = theCart;
dnaUtilOpen();
orgChange = sameOk(cgiOptionalString("changeInfo"),"orgChange");
if (orgChange)
{
cgiVarSet("db", hDefaultDbForGenome(cgiOptionalString("org")));
}
getDbAndGenome(cart, &db, &organism, oldVars);
char *oldDb = cloneString(db);
findClosestServer(&db, &organism);
/* Get sequence - from userSeq variable, or if
* that is empty from a file. */
if (clearUserSeq)
{
cartSetString(cart, "userSeq", "");
cartSetString(cart, "seqFile", "");
}
userSeq = cartUsualString(cart, "userSeq", "");
if (isEmpty(userSeq))
{
userSeq = cartOptionalString(cart, "seqFile");
}
if (isEmpty(userSeq) || orgChange)
{
cartWebStart(theCart, db, "%s BLAT Search", trackHubSkipHubName(organism));
if (differentString(oldDb, db))
printf("<HR><P><EM><B>Note:</B> BLAT search is not available for %s %s; "
"defaulting to %s %s</EM></P><HR>\n",
hGenome(oldDb), hFreezeDate(oldDb), organism, hFreezeDate(db));
askForSeq(organism,db);
cartWebEnd();
}
else
{
blatSeq(skipLeadingSpaces(userSeq), organism);
}
}
void columnVarsFromSettings(struct column *col, char *fileName)
/* Grab a bunch of variables from col->settings and
* move them into col proper. */
{
struct hash *settings = col->settings;
col->name = mustFindInRaHash(fileName, settings, "name");
spaceToUnderbar(col->name);
col->shortLabel = mustFindInRaHash(fileName, settings, "shortLabel");
col->longLabel = mustFindInRaHash(fileName, settings, "longLabel");
col->priority = atof(mustFindInRaHash(fileName, settings, "priority"));
col->on = col->defaultOn =
sameString(mustFindInRaHash(fileName, settings, "visibility"), "on");
col->filterOn = FALSE;
col->type = mustFindInRaHash(fileName, settings, "type");
col->query = hashFindVal(settings, "query");
col->filterDropDown = sameOk(hashFindVal(settings, "filterDropDown"), "on");
col->colNo = -1;
}
int main(int argc, char *argv[])
{
long enteredMainTime = clock1000();
cgiSpoof(&argc, argv);
char *database = cgiOptionalString("db");
char *prefix = cgiOptionalString("prefix");
char *type = cgiOptionalString("type");
char *table = checkParams(database, prefix, type);
puts("Content-Type:text/plain");
puts("\n");
if (sameOk(type, ALT_OR_PATCH))
suggestAltOrPatch(database, prefix);
else
suggestGene(database, table, prefix);
cgiExitTime("hgSuggest", enteredMainTime);
return 0;
}
char *checkParams(char *database, char *prefix, char *type)
/* If we don't have valid CGI parameters, quit with a Bad Request HTTP response. */
{
pushWarnHandler(htmlVaBadRequestAbort);
pushAbortHandler(htmlVaBadRequestAbort);
if(prefix == NULL || database == NULL)
errAbort("%s", "Missing prefix and/or db CGI parameter");
if (! hDbIsActive(database))
errAbort("'%s' is not a valid, active database", htmlEncode(database));
if (isNotEmpty(type) && differentString(type, ALT_OR_PATCH))
errAbort("'%s' is not a valid type", type);
char *table = NULL;
if (! sameOk(type, ALT_OR_PATCH))
{
struct sqlConnection *conn = hAllocConn(database);
table = connGeneSuggestTable(conn);
hFreeConn(&conn);
if(table == NULL)
errAbort("gene autosuggest is not supported for db '%s'", database);
}
popWarnHandler();
popAbortHandler();
return table;
}
struct raRecord *findRecordAtLevel(struct raLevel *level, char *key, char *release)
/* Find record of given key and release in level. */
{
/* Look up key in hash */
struct hashEl *firstEl = hashLookup(level->trackHash, key);
/* Loop through and return any ones that match on both key (implicit in hash find) and
* in release. */
struct hashEl *hel;
for (hel = firstEl; hel != NULL; hel = hashLookupNext(hel))
{
struct raRecord *r = hel->val;
struct raTag *releaseTag = raRecordFindTag(r, "release");
char *rRelease = (releaseTag == NULL ? NULL : releaseTag->val);
if (sameOk(release, rRelease))
return r;
}
/* If given record hash no defined release, return first match regardless of release. */
if (release == NULL && firstEl != NULL)
return firstEl->val;
return NULL;
}
static void bigBedClick(char *fileName, struct trackDb *tdb,
char *item, int start, int end, int bedSize)
/* Handle click in generic bigBed track. */
{
boolean showUrl = FALSE;
char *chrom = cartString(cart, "c");
/* Open BigWig file and get interval list. */
struct bbiFile *bbi = bigBedFileOpen(fileName);
struct lm *lm = lmInit(0);
int ivStart = start, ivEnd = end;
if (start == end)
{
// item is an insertion; expand the search range from 0 bases to 2 so we catch it:
ivStart = max(0, start-1);
ivEnd++;
}
struct bigBedInterval *bbList = bigBedIntervalQuery(bbi, chrom, ivStart, ivEnd, 0, lm);
/* Get bedSize if it's not already defined. */
if (bedSize == 0)
{
bedSize = bbi->definedFieldCount;
showUrl = TRUE;
}
char *scoreFilter = cartOrTdbString(cart, tdb, "scoreFilter", NULL);
int minScore = 0;
if (scoreFilter)
minScore = atoi(scoreFilter);
/* Find particular item in list - matching start, and item if possible. */
boolean found = FALSE;
boolean firstTime = TRUE;
struct bigBedInterval *bb;
for (bb = bbList; bb != NULL; bb = bb->next)
{
if (!(bb->start == start && bb->end == end))
continue;
if (bedSize > 3)
{
char *name = cloneFirstWordByTab(bb->rest);
boolean match = sameString(name, item);
freez(&name);
if (!match)
continue;
}
found = TRUE;
if (firstTime)
printf("<BR>\n");
int seq1Seq2Fields = 0;
// check for seq1 and seq2 in columns 7+8 (eg, pairedTagAlign)
boolean seq1Seq2 = sameOk(trackDbSetting(tdb, BASE_COLOR_USE_SEQUENCE), "seq1Seq2");
if (seq1Seq2 && bedSize == 6)
seq1Seq2Fields = 2;
char *fields[bedSize+seq1Seq2Fields];
char startBuf[16], endBuf[16];
char *rest = cloneString(bb->rest);
int bbFieldCount = bigBedIntervalToRow(bb, chrom, startBuf, endBuf, fields,
bedSize+seq1Seq2Fields);
if (bbFieldCount != bedSize+seq1Seq2Fields)
{
errAbort("Disagreement between trackDb field count (%d) and %s fieldCount (%d)",
bedSize, fileName, bbFieldCount);
}
struct bed *bed = bedLoadN(fields, bedSize);
if (bedSize >= 6 && scoreFilter && bed->score < minScore)
continue;
if (showUrl && (bedSize >= 4))
printCustomUrl(tdb, item, TRUE);
bedPrintPos(bed, bedSize, tdb);
// display seq1 and seq2
if (seq1Seq2 && bedSize+seq1Seq2Fields == 8)
printf("<table><tr><th>Sequence 1</th><th>Sequence 2</th></tr>"
"<tr><td> %s </td><td> %s </td></tr></table>", fields[6], fields[7]);
else if (isNotEmpty(rest))
{
char *restFields[256];
int restCount = chopTabs(rest, restFields);
int restBedFields = bedSize - 3;
if (restCount > restBedFields)
{
if (0 == extraFieldsPrint(tdb,NULL,restFields + restBedFields,restCount - restBedFields))
{
int i;
char label[20];
safef(label, sizeof(label), "nonBedFieldsLabel");
printf("<B>%s </B>",
trackDbSettingOrDefault(tdb, label, "Non-BED fields:"));
for (i = restBedFields; i < restCount; i++)
printf("%s%s", (i > 0 ? "\t" : ""), restFields[i]);
printf("<BR>\n");
}
}
}
if (isCustomTrack(tdb->track))
{
time_t timep = bbiUpdateTime(bbi);
printBbiUpdateTime(&timep);
}
}
if (!found)
{
printf("No item %s starting at %d\n", emptyForNull(item), start);
}
lmCleanup(&lm);
bbiFileClose(&bbi);
}
struct mimePart *parseMultiParts(struct mimeBuf *b, char *altHeader)
/* This is a recursive function. It parses multipart MIME messages.
Data that are binary or too large will be saved in mimePart->filename
otherwise saved as a c-string in mimePart->data. If multipart,
then first child is mimePart->child, subsequent sibs are in child->next.
altHeader is a string of headers that can be fed in if the headers have
already been read off the stream by an earlier process, i.e. apache.
*/
{
struct mimePart *p=AllocA(*p);
char *parentboundary = NULL, *boundary = NULL;
char *ct = NULL;
boolean autoBoundary = FALSE;
//debug
//fprintf(stderr,"altHeader=[%s]\n",altHeader);
if (sameOk(altHeader, "autoBoundary"))
{ /* process things with no explicit header.
* look for *MIME* \n\n-- */
struct dyString *dy = dyStringNew(0);
char *prevPrevLine = NULL;
char *prevLine = NULL;
char *line = NULL;
boolean found = FALSE;
autoBoundary = TRUE;
while (TRUE)
{
if (b->i >= b->eoi && b->eoi < b->eom) /* at end of input */
break;
line = getLineMB(b);
if (line && startsWith("--",line) // &&
//sameString(prevLine,"") &&
//prevPrevLine &&
//stringIn("MULTI",prevPrevLine) &&
//stringIn("MIME",prevPrevLine)
)
{
found = TRUE;
break;
}
freez(&prevPrevLine);
prevPrevLine = prevLine;
prevLine = line;
if (prevPrevLine)
touppers(prevPrevLine);
}
if (!found)
errAbort("autoBoundary: No initial boundary found.");
dyStringPrintf(dy, "CONTENT-TYPE:multipart/form-data; boundary=%s%s%s",
line+2, getNewLineByType(), getNewLineByType() );
altHeader = dyStringCannibalize(&dy);
//debug
//fprintf(stderr,"autoBoundary altHeader = [%s]\n",altHeader);
//fflush(stderr);
freez(&prevPrevLine);
freez(&prevLine);
freez(&line);
}
//debug
//fprintf(stderr,"\n");
readPartHeaderMB(b,p,altHeader);
ct = hashFindVal(p->hdr,"content-type"); /* use lowercase key */
//debug
//fprintf(stderr,"ct from hash:%s\n",ct);
//fflush(stderr);
if (ct && startsWith("multipart/",ct))
{
char bound[MAXBOUNDARY];
char *bnd = NULL;
struct mimePart *child = NULL;
/* these 3 vars just for processing epilog chunk: */
char *bp=NULL;
int size=0;
boolean hasZeros=FALSE;
/* save */
parentboundary = b->boundary;
boundary = getMimeHeaderFieldVal(ct,"boundary");
if (strlen(boundary) >= MAXBOUNDARY)
errAbort("error: boundary= value too long in MIME header Content-type:%s",ct);
safef(bound, sizeof(bound), "--%s",boundary); /* do not prepend CRLF to boundary yet */
freez(&boundary);
boundary = cloneString(bound);
//debug
//fprintf(stderr,"initial boundary parsed:%s\n",boundary);
//fflush(stderr);
if (!autoBoundary)
{
/* skip any extra "prolog" before the initial boundary marker */
while (TRUE)
{
bnd = getLineMB(b);
if (sameString(bnd,boundary))
break;
freez(&bnd);
}
//debug
//fprintf(stderr,"initial boundary found:%s\n",bnd);
//fflush(stderr);
freez(&bnd);
}
/* include crlf in the boundary so bodies won't have trailing a CRLF
* this is done here so that in case there's no extra CRLF
* between the header and the boundary, it will still work,
* so we only prepend the CRLF to the boundary after initial found */
safef(bound,sizeof(bound),"%s%s", getNewLineByType(), boundary);
freez(&boundary);
boundary=cloneString(bound);
setBoundaryMB(b, boundary);
while(TRUE)
{
int i = 0;
char c1 = ' ', c2 = ' ';
child = parseMultiParts(b,NULL);
slAddHead(&p->multi,child);
//call getLine, compare to boundary
/* skip extra initial boundary marker - it's moot anyway */
freez(&bnd);
//debug
//fprintf(stderr,"post-parse pre-getLineMB dumpMB: ");
//dumpMB(b); //debug
for (i=0;i<strlen(boundary);++i)
bound[i] = getcMB(b);
bound[i] = 0;
if (!sameString(bound,boundary))
errAbort("expected boundary %s, but found %s in MIME",boundary,bound);
//debug
//fprintf(stderr,"\nfound boundary:%s\n",bound);
//fflush(stderr);
c1 = getcMB(b);
if (c1 == '-')
{
c2 = getcMB(b);
if (c2 == '-')
break; /* last boundary found */
else
errAbort("expected -- after boundary %s, but found %c%c in MIME",boundary,c1,c2);
}
if (nlType == nlt_dos)
c2 = getcMB(b);
switch (nlType)
{
case nlt_dos:
if (c1 == 0x0d && c2 == 0x0a)
break;
else
errAbort("expected CRLF after boundary %s, but found %c%c in MIME",boundary,c1,c2);
case nlt_unix:
if (c1 == 0x0a)
break;
else
errAbort("expected LF after boundary %s, but found %c in MIME",boundary,c1);
case nlt_mac:
if (c1 == 0x0d)
break;
else
errAbort("expected CR after boundary %s, but found %c in MIME",boundary,c1);
default:
errAbort("unexpected nlType %d after boundary %s",nlType,boundary);
}
setEopMB(b);
}
freez(&bnd);
slReverse(&p->multi);
/* restore */
freez(&boundary);
boundary = parentboundary;
//debug
//fprintf(stderr,"restoring parent boundary = %s\n",boundary);
setBoundaryMB(b, boundary);
/* dump any "epilog" that may be between the
* end of the child boundary and the parent boundary */
getChunkMB(b, &bp, &size, &hasZeros);
//debug
//fprintf(stderr,"epilog size=%d\n",size);
}
else
{
char *bp=NULL;
int size=0;
boolean hasZeros=FALSE;
boolean toobig=FALSE;
boolean asFile=FALSE;
boolean convert=FALSE;
FILE *f = NULL;
struct dyString *dy=newDyString(1024);
//debug
//fprintf(stderr,"starting new part (non-multi), dumpMB: \n");
//dumpMB(b); //debug
//debug
//ct = hashFindVal(p->hdr,"content-transfer-encoding"); /* use lowercase key */
//fprintf(stderr,"cte from hash:%s\n",ct);
while(TRUE)
{
// break if eop, eod, eoi
getChunkMB(b, &bp, &size, &hasZeros);
//debug
//fprintf(stderr,"bp=%lu size=%d, hasZeros=%d \n",
// (unsigned long) bp,
// size,
// hasZeros);
if (hasZeros)
{
p->binary=TRUE;
}
//if (hasZeros && !asFile)
// {
// convert=TRUE;
// }
if (!asFile && p->size+size > MAXPARTSIZE)
{
toobig = TRUE;
convert=TRUE;
}
if (convert)
{
struct tempName uploadedData;
convert=FALSE;
asFile = TRUE;
makeTempName(&uploadedData, "hgSs", ".cgi");
p->fileName=cloneString(uploadedData.forCgi);
f = mustOpen(p->fileName,"w");
mustWrite(f,dy->string,dy->stringSize);
freeDyString(&dy);
}
if (asFile)
{
mustWrite(f,bp,size);
}
else
{
dyStringAppendN(dy,bp,size);
}
p->size+=size;
if (p->size > MAXDATASIZE)
errAbort("max data size allowable for upload in MIME exceeded %llu",(unsigned long long)MAXDATASIZE);
if (b->eop && b->i == b->eop) /* end of part */
{
break;
}
if (b->i == b->eoi && b->eoi < b->eom) /* end of data */
{
break;
}
moreMimeBuf(b);
}
if (dy)
{
p->data=needLargeMem(dy->stringSize+1);
memcpy(p->data,dy->string,dy->stringSize);
p->data[dy->stringSize] = 0;
freeDyString(&dy);
}
if (f)
carefulClose(&f);
//debug
//fprintf(stderr,"p->fileName=%s p->data=[%s]\n",p->fileName,p->data);
}
return p;
}
void verifyGreatAssemblies()
{
// First read in the assembly name and description information into name lists
struct slName* supportedAssemblies = NULL;
struct lineFile *lf = lineFileOpen(greatData, TRUE);
int fieldCount = 1;
char* row[fieldCount];
int wordCount;
while ((wordCount = lineFileChopTab(lf, row)) != 0)
{
if (wordCount != fieldCount)
errAbort("The %s file is not properly formatted.\n", greatData);
slNameAddHead(&supportedAssemblies, row[0]);
}
lineFileClose(&lf);
boolean invalidAssembly = TRUE;
struct slName* currAssembly;
for (currAssembly = supportedAssemblies; currAssembly != NULL; currAssembly = currAssembly->next)
{
if (!hDbIsActive(currAssembly->name))
{
errAbort("Assembly %s in supported assembly file is not an active assembly.\n", currAssembly->name);
}
if (sameOk(database, currAssembly->name))
{
invalidAssembly = FALSE;
break;
}
}
if (invalidAssembly)
{
slReverse(&supportedAssemblies);
currAssembly = supportedAssemblies;
struct dyString* dy = dyStringNew(0);
addAssemblyToSupportedList(dy, currAssembly->name);
currAssembly = currAssembly->next;
while (currAssembly != NULL)
{
dyStringAppend(dy, ", ");
if (currAssembly->next == NULL)
dyStringAppend(dy, "and ");
addAssemblyToSupportedList(dy, currAssembly->name);
currAssembly = currAssembly->next;
}
hPrintf("<script type='text/javascript'>\n");
hPrintf("function logSpecies() {\n");
hPrintf("try {\n");
hPrintf("var r = new XMLHttpRequest();\n");
hPrintf("r.open('GET', 'http://great.stanford.edu/public/cgi-bin/logSpecies.php?species=%s');\n", database);
hPrintf("r.send(null);\n");
hPrintf("} catch (err) { }\n");
hPrintf("}\n");
hPrintf("window.onload = logSpecies;\n");
hPrintf("</script>\n");
errAbort("GREAT only supports the %s assemblies."
"\nPlease go back and ensure that one of those assemblies is chosen.",
dyStringContents(dy));
htmlClose();
dyStringFree(&dy);
}
slNameFreeList(&supportedAssemblies);
}
void doGzippedBedToBigBed(struct encode2Manifest *mi, char *bedFile, char *destPath,
char *assembly, char *asType, char *bedType, char *midFix,
char *destDir, char *destFileName,
struct slName **pTargetList, FILE *f, FILE *manF)
/* Convert some bed file to a a bigBed file possibly using an as file. */
{
/* First handle the straight up copy - even though minimal changes to bigBed,
* for archival purposes Eurie and Cricket want original bed too. */
fprintf(f, "%s: %s\n", destPath, bedFile);
fprintf(f, "\tln -s %s %s\n", bedFile, destPath);
slNameAddHead(pTargetList, destPath);
encode2ManifestShortTabOut(mi, manF);
/* Figure out name of bigBed file we will output and write it as a make target. */
char outFileName[FILENAME_LEN];
safef(outFileName, sizeof(outFileName), "%s%s", destFileName, ".bigBed");
char outPath[PATH_LEN];
safef(outPath, sizeof(outPath), "%s%s%s", destDir, destFileName, ".bigBed");
fprintf(f, "%s: %s\n", outPath, bedFile);
/* Unpack gzipped bed and sort it. */
char *tempNameRoot = "b2bb";
char *clippedBed = veryTempName(tempDir, tempNameRoot, ".clipped");
if (sameOk(asType, "peptideMapping")) // special cleanups...
fprintf(f, "\tzcat %s | tr '\\r' '\\n' | grep -v '^track' | cut -f 1-10 "
"| bedClip stdin %s/%s/chrom.sizes %s\n",
bedFile, dataDir, assembly, clippedBed);
else
fprintf(f, "\tzcat %s | grep -v '^track' | bedClip stdin %s/%s/chrom.sizes %s\n",
bedFile, dataDir, assembly, clippedBed);
char *sortedBed = veryTempName(tempDir, tempNameRoot, ".sorted.bed");
fprintf(f, "\tsort -k1,1 -k2,2n %s > %s\n", clippedBed, sortedBed);
fprintf(f, "\trm %s\n", clippedBed);
/* Figure out if it's one we need to doctor up, and if so emit that code */
char *doctoredBed = NULL;
char *bigBedSource = NULL;
if (needsBedDoctor(destFileName))
{
doctoredBed = veryTempName(tempDir, "b2bb", ".doctored.bed");
if (asType == NULL)
fprintf(f, "\tencode2BedDoctor %s %s\n", sortedBed, doctoredBed);
else
fprintf(f, "\tencode2BedPlusDoctor %s %s/as/%s.as %s\n", sortedBed,
dataDir, asType, doctoredBed);
fprintf(f, "\trm %s\n", sortedBed);
bigBedSource = doctoredBed;
}
else
{
bigBedSource = sortedBed;
}
/* Write bigBed, initially to a temp name, and then moving it to real name if all went well. */
char tempBigBed[PATH_LEN];
safef(tempBigBed, sizeof(tempBigBed), "%s.tmp", outPath);
fprintf(f, "\tbedToBigBed ");
if (bedType != NULL)
fprintf(f, " -type=%s", bedType);
if (asType != NULL)
fprintf(f, " -as=%s/as/%s.as", dataDir, asType);
fprintf(f, " %s %s/%s/chrom.sizes %s\n", bigBedSource, dataDir, assembly, tempBigBed);
fprintf(f, "\tmv %s %s\n", tempBigBed, outPath);
fprintf(f, "\trm %s\n", bigBedSource);
/* Add to target list. */
slNameAddHead(pTargetList, outPath);
/* Print out info about bigBed we made to new manifest files. */
char localFileName[PATH_LEN+8]; // a little extra for .bigBed
safef(localFileName, PATH_LEN, "%s", mi->fileName);
chopSuffix(localFileName); // Chop off .gz
if (midFix != NULL) // If midfix, replace .narrowPeak etc with midFix. Used to get rid of .bed
{
chopSuffix(localFileName);
strcat(localFileName, midFix);
}
strcat(localFileName, ".bigBed");
mi->fileName = localFileName;
mi->format = asType;
encode2ManifestShortTabOut(mi, manF);
}
boolean asCompareObjs(char *name1, struct asObject *as1, char *name2, struct asObject *as2, int numColumnsToCheck,
int *retNumColumnsSame, boolean abortOnDifference)
/* Compare as-objects as1 and as2 making sure several important fields show they are the same name and type.
* If difference found, print it to stderr. If abortOnDifference, errAbort.
* Othewise, return TRUE if the objects columns match through the first numColumnsToCheck fields.
* If retNumColumnsSame is not NULL, then it will be set to the number of contiguous matching columns. */
{
boolean differencesFound = FALSE;
struct asColumn *col1 = as1->columnList, *col2 = as2->columnList;
int checkCount = 0;
int verboseLevel = 2;
if (abortOnDifference)
verboseLevel = 1;
if (as1->isTable != as2->isTable)
{
verbose(verboseLevel,"isTable does not match: %s=[%d] %s=[%d]", name1, as1->isTable, name2, as2->isTable);
differencesFound = TRUE;
}
else if (as1->isSimple != as2->isSimple)
{
verbose(verboseLevel,"isSimple does not match: %s=[%d] %s=[%d]", name1, as1->isSimple, name2, as2->isSimple);
differencesFound = TRUE;
}
else
{
if (!as1->isTable)
{
errAbort("asCompareObjLists only supports Table .as objects at this time.");
}
for (col1 = as1->columnList, col2 = as2->columnList;
col1 != NULL && col2 != NULL && checkCount < numColumnsToCheck;
col1 = col1->next, col2 = col2->next, ++checkCount)
{
if (!sameOk(col1->name, col2->name))
{
verbose(verboseLevel,"column #%d names do not match: %s=[%s] %s=[%s]\n"
, checkCount+1, name1, col1->name, name2, col2->name);
differencesFound = TRUE;
break;
}
else if (col1->isSizeLink != col2->isSizeLink)
{
verbose(verboseLevel,"column #%d isSizeLink do not match: %s=[%d] %s=[%d]\n"
, checkCount+1, name1, col1->isSizeLink, name2, col2->isSizeLink);
differencesFound = TRUE;
break;
}
else if (col1->isList != col2->isList)
{
verbose(verboseLevel,"column #%d isList do not match: %s=[%d] %s=[%d]\n"
, checkCount+1, name1, col1->isList, name2, col2->isList);
differencesFound = TRUE;
break;
}
else if (col1->isArray != col2->isArray)
{
verbose(verboseLevel,"column #%d isArray do not match: %s=[%d] %s=[%d]\n"
, checkCount+1, name1, col1->isArray, name2, col2->isArray);
differencesFound = TRUE;
break;
}
else if (!sameOk(col1->lowType->name, col2->lowType->name))
{
verbose(verboseLevel,"column #%d type names do not match: %s=[%s] %s=[%s]\n"
, checkCount+1, name1, col1->lowType->name, name2, col2->lowType->name);
differencesFound = TRUE;
break;
}
else if (col1->fixedSize != col2->fixedSize)
{
verbose(verboseLevel,"column #%d fixedSize do not match: %s=[%d] %s=[%d]\n"
, checkCount+1, name1, col1->fixedSize, name2, col2->fixedSize);
differencesFound = TRUE;
break;
}
else if (!sameOk(col1->linkedSizeName, col2->linkedSizeName))
{
verbose(verboseLevel,"column #%d linkedSizeName do not match: %s=[%s] %s=[%s]\n"
, checkCount+1, name1, col1->linkedSizeName, name2, col2->linkedSizeName);
differencesFound = TRUE;
break;
}
}
if (!differencesFound && checkCount < numColumnsToCheck)
errAbort("Unexpected error in asCompareObjLists: asked to compare %d columns in %s and %s, but only found %d in one or both asObjects."
, numColumnsToCheck, name1, name2, checkCount);
}
if (differencesFound)
{
if (abortOnDifference)
errAbort("asObjects differ.");
else
verbose(verboseLevel,"asObjects differ. Matching field count=%d\n", checkCount);
}
if (retNumColumnsSame)
*retNumColumnsSame = checkCount;
return (!differencesFound);
}
double scoreLiftOverChain(struct liftOverChain *chain,
char *fromOrg, char *fromDb, char *toOrg, char *toDb,
char *cartOrg, char *cartDb, struct hash *dbRank )
/* Score the chain in terms of best match for cart settings */
{
double score = 0;
char *chainFromOrg = hArchiveOrganism(chain->fromDb);
char *chainToOrg = hArchiveOrganism(chain->toDb);
int fromRank = hashIntValDefault(dbRank, chain->fromDb, 0); /* values up to approx. #assemblies */
int toRank = hashIntValDefault(dbRank, chain->toDb, 0);
int maxRank = hashIntVal(dbRank, "maxRank");
if (sameOk(fromOrg,chainFromOrg) &&
sameOk(fromDb,chain->fromDb) &&
sameOk(toOrg,chainToOrg) &&
sameOk(toDb,chain->toDb))
score += 10000000;
if (sameOk(fromOrg,chainFromOrg))
score += 2000000;
if (sameOk(fromDb,chain->fromDb))
score += 1000000;
if (sameOk(toOrg,chainToOrg))
score += 200000;
if (sameOk(toDb,chain->toDb))
score += 100000;
if (sameOk(cartDb,chain->fromDb))
score += 20000;
if (sameOk(cartDb,chain->toDb))
score += 10000;
if (sameOk(cartOrg,chainFromOrg))
score += 2000;
if (sameOk(cartOrg,chainToOrg))
score += 1000;
score += 10*(maxRank-fromRank);
score += (maxRank - toRank);
return score;
}
static void pubsLoadKeywordYearItems(struct track *tg)
/* load items that fulfill keyword and year filter */
{
pubsParseClassColors();
struct sqlConnection *conn = hAllocConn(database);
char *keywords = cartOptionalStringClosestToHome(cart, tg->tdb, FALSE, "pubsFilterKeywords");
char *yearFilter = cartOptionalStringClosestToHome(cart, tg->tdb, FALSE, "pubsFilterYear");
char *publFilter = cartOptionalStringClosestToHome(cart, tg->tdb, FALSE, "pubsFilterPublisher");
char *articleTable = pubsArticleTable(tg);
if(sameOk(yearFilter, "anytime"))
yearFilter = NULL;
if(sameOk(publFilter, "all"))
publFilter = NULL;
if(isNotEmpty(keywords))
keywords = makeMysqlMatchStr(keywords);
if (isEmpty(yearFilter) && isEmpty(keywords) && isEmpty(publFilter))
{
loadGappedBed(tg);
}
else
{
// put together an "extra" query to hExtendedRangeQuery that removes articles
// without the keywords specified in hgTrackUi
char *oldLabel = tg->longLabel;
tg->longLabel = catTwoStrings(oldLabel, " (filter activated)");
freeMem(oldLabel);
char **row;
struct linkedFeatures *lfList = NULL;
struct trackDb *tdb = tg->tdb;
int scoreMin = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMin", "0"));
int scoreMax = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMax", "1000"));
boolean useItemRgb = bedItemRgb(tdb);
char *extra = NULL;
struct dyString *extraDy = dyStringNew(0);
struct hash *articleIds = searchForKeywords(conn, articleTable, keywords);
if (!sameWord(tg->table, "pubsBlat"))
// new table schema: filter fields are on main bed table
{
if (isNotEmpty(yearFilter))
sqlDyStringPrintfWithSep(extraDy, " AND ", " year >= '%s'", yearFilter);
if (isNotEmpty(publFilter))
sqlDyStringPrintfWithSep(extraDy, " AND ", " publisher = '%s'", publFilter);
}
else
// old table schema, filter by doing a join on article table
{
if(isNotEmpty(yearFilter))
sqlDyStringPrintfFrag(extraDy, "name IN (SELECT articleId FROM %s WHERE year>='%s')", articleTable, \
yearFilter);
}
if (extraDy->stringSize > 0)
extra = extraDy->string;
else
extra = NULL;
int rowOffset = 0;
struct sqlResult *sr = hExtendedRangeQuery(conn, tg->table, chromName, winStart, winEnd, extra,
FALSE, NULL, &rowOffset);
freeDyString(&extraDy);
while ((row = sqlNextRow(sr)) != NULL)
{
struct bed *bed = bedLoad12(row+rowOffset);
if (articleIds==NULL || hashFindVal(articleIds, bed->name))
slAddHead(&lfList, bedMungToLinkedFeatures(&bed, tdb, 12, scoreMin, scoreMax, useItemRgb));
}
sqlFreeResult(&sr);
slReverse(&lfList);
slSort(&lfList, linkedFeaturesCmp);
tg->items = lfList;
}
hFreeConn(&conn);
}