// Released under the MIT/X11 license
// http://www.opensource.org/licenses/mit-license.php
// For identification of graphics card
var manuChipStrs = [ [ "ATI Radeon", "ATI", "1002" ],
[ "ATI Mobility Radeon", "ATI", "1002" ],
[ "Intel Corporation", "INTEL", "8086" ], [ "NVIDIA", "NV", "10de" ] ];
// http://en.wikipedia.org/wiki/HSL_color_space
// when only the value of S is changed
// stupido!!! the string is value in hex for each color
var RHColor = new Color(158, 41, 43); // RGB 158, 41, 43; HSL 359, 1, 39
var FedoraColor = new Color(0, 40, 103); // RGB 0, 40, 103; HSL 359, 1, 39
var RawhideColor = new Color(0, 119, 0); // or "green", or RGB 0, 119, 0, or
// HSL
// 120, 0, 23
var RHITColor = new Color(102, 0, 102); // RGB 102, 0, 102; HSL 300, 0, 20
var titleParsedAttachment = "Part of the thread where crash happened";
// [ 126.386] (--) NOUVEAU(0): Chipset: "NVIDIA NVaf"
var logAnalyzeLogic = {
"AnalyzeInterestingLine": {
/*
* [ 126.378] (--) PCI:*(0:4:0:0) 10de:08a0:106b:00c2 rev 162, Mem @
* 0xd2000000/16777216, \ 0xc0000000/268435456, 0xd0000000/33554432, I/O @
* 0x00001000/128, BIOS @ 0x????????/131072
*/
re: [
"^(\\[[ .0-9]+\\])?\\s*\\(--\\) PCI:\\*\\([0-9:]+\\)\\s*" +
"([0-9a-f:]+).*$",
"^\\s*\\[?[ 0-9.]*\\]?\\s*\\(--\\) "+
"([A-Za-z]+)\\([0-9]?\\): Chipset: (.*)$",
],
func: chipsetMagic
},
/*
* [ 126.385] (WW) Falling back to old probe method for vesa [ 126.385] (WW)
* Falling back to old probe method for fbdev [ 126.386] (--) NOUVEAU(0):
* Chipset: "NVIDIA NVaf" Backtrace: [ 33.158] Kernel command line: ro
* root=LABEL=root rd_NO_LUKS rd_NO_LVM rd_NO_MD rd_NO_DM LANG=en_US.UTF-8
* SYSFONT=latarcyrheb-sun16 KEYTABLE=us drm.debug=0x04
*
*/
"AnalyzeXorgLogBacktrace": {
re: "^\\s*(\\[[0-9 .]*\\])?\\s*(\\((EE|WW)\\)|.* [cC]hipset:.*)|\\s*(Backtrace|Kernel command line)",
func: analyzeXorg
}
};
var ProfessionalProducts = [
"Red Hat Enterprise Linux",
"Red Hat Enterprise MRG"
];
// END OF CONSTANTS
var btSnippet = null;
function RHOnMessageHandler(msg, nextHandler) {
switch (msg.cmd) {
case "Error":
alert("Error " + msg.data);
break;
case "Unhandled":
break;
case "AddAttachmentCallback":
addAttachmentCallback(msg.data);
break;
case "FixAttachmentMIMECallback":
XMLRPCcallback();
break;
case "AnalyzeInterestingLine":
case "AnalyzeXorgLogBacktrace":
findInterestingLine(msg.data, msg.cmd);
break;
case "queryUpstream":
queryUpstreamCallback(msg.data, constantData.queryUpstreamBug);
break;
default:
if (nextHandler) {
var nextHandler = nextHandlerList.splice(0, 1);
if (nextHandler[0]) {
nextHandler[0](msg, nextHandlerList);
}
}
else {
console.error("Error: unknown RPC call " + msg.toSource());
}
break;
}
}
// RHBugzillaPage object
/**
* Auxiliary function to compute more complicated resolution
*/
function closeSomeRelease() {
// for RAWHIDE close as RAWHIDE,
// if active selection -> CURRENTRELEASE
// and put the release version to
// "Fixed in Version" textbox
// otherwise -> NEXTRELEASE
selectOption("bug_status", "CLOSED");
var text = getSelection();
var resolution = "";
if (text.length > 0) {
resolution = "CURRENTRELEASE";
document.getElementById("cf_fixed_in").value = text;
}
else if (document.getElementById("version").value === "rawhide") {
resolution = "RAWHIDE";
}
else {
resolution = "NEXTRELEASE";
}
centralCommandDispatch("resolution", resolution);
}
/**
* Additional commands specific for this subclass, overriding superclass one.
*/
function RHcentralCommandDispatch(cmdLabel, cmdParams) {
switch (cmdLabel) {
// Set up our own commands
case "closeUpstream":
addClosingUpstream();
break;
case "computeResolution":
closeSomeRelease();
break;
case "queryStringUpstreamBugzilla":
queryUpstream(constantData.queryUpstreamBug);
break;
case "sendBugUpstream":
sendBugUpstream();
break;
case "markTriaged":
markBugTriaged();
break;
case "chipMagic":
fillInWhiteBoard(cmdParams);
break;
// If we don't have it here, call superclass method
default:
if (MozCentralCommandDispatch) {
MozCentralCommandDispatch(cmdLabel, cmdParams);
}
else {
console.error("Unknown command:\n" + cmdLabel + "\nparameters:\n" + cmdParams);
}
break;
}
}
/**
* Make it sailent that the some attachments with bad MIME type are present
*
* @param atts
* Array of attachments subarrays
* @return none
*/
function markBadAttachments(atts) {
var badMIMEArray = [ "application/octet-stream", "text/x-log", "undefined" ];
if (!constantData.passwordState.passAvailable) {
console.myDebug("markBadAttachments : No password, no XML-RPC calls; sorry");
return null;
}
var badAttachments = atts.filter(function(att) {
return (isInList(att[2], badMIMEArray));
});
if (badAttachments.length > 0) {
var titleElement = document.
getElementsByClassName("bz_alias_short_desc_container")[0];
titleElement.style.backgroundColor = "olive";
createDeadLink("fixAllButton", "Fix all", titleElement, function() {
Array.forEach(badAttachments, function(x) {
fixAttachById(x[1], constantData.XMLRPCData[window.location.hostname].url);
});
}, [], false, null, "f");
badAttachments.forEach(function(x, i, a) {
addTextLink(x, constantData.XMLRPCData[window.location.hostname].url);
});
}
}
/**
* Open a tab in the upstream bugzilla to create a new bug
*
* @return none
*/
function sendBugUpstream() {
var admitMsg = "(originally filed as " + window.location.href + ")\n\n";
var urlStr = filterByRegexp(constantData.newUpstreamBug, getComponent());
if (!urlStr) {
return null;
}
self.postMessage(new Message("OpenBugUpstream", {
url: urlStr,
subject: document.getElementById("short_desc_nonedit_display").
textContent.trim(),
comment: admitMsg + collectComments()
}));
}
/**
* Add a link opening selected lines of Xorg.0.log
*
* @return none
*/
function addCheckXorgLogLink(attList) {
if (config.XorgLogAnalysis) {
attList.forEach(function (row) {
var elemS = row[4].getElementsByTagName("td");
var elem = elemS[elemS.length - 1];
createDeadLink("xorgLogAnalyzeLink", "check", elem,
analyzeXorgLog, [row[1], "AnalyzeXorgLogBacktrace"], "br");
});
}
}
/**
* Given line to be parsed, find out which chipset it is and fill in the
* whiteboard
*
* @param PCIidArrObj
* object with two fields id Array manufacturer-ID and product-ID (PCI
* IDs) chipsetLine whole line containing PCI ID.
* @param driverStr
* String with the driver name
* @return None
*
*/
function fillInWhiteBoard(cardName) {
console.myDebug("fillInWhiteBoard: cardName = " + cardName);
clickMouse("editme_action");
var titleElem = document.getElementById('short_desc');
titleElem.value = '[' + cardName + ']\u00A0' + titleElem.value;
document.getElementById("fillin_btn").style.display = "none";
}
/**
* Get attached Xorg.0.log, parse it and find the value of chip. Does not fill
* the whiteboard itself, just adds button to do so,paramList so that slow
* XMLHttpRequest is done in advance.
*
* @param log
* array of XorgLogAttList
* @return None
*/
function fillInChipMagic(XlogID) {
analyzeXorgLog(XlogID, "AnalyzeInterestingLine");
}
/**
* Creates a button to change summary by adding a graphic chip label
*
* @param Array
* with matching results of re.exec()
*/
function chipsetMagic (interestingLineArr) {
// parse Xorg.0.log
var cardStr = "";
console.myDebug("interestingLineArr[1] = " + interestingLineArr[1]);
if (interestingLineArr.length >0) {
var interestingArray = interestingLineArr[0];
if (interestingArray.length > 1) {
var interestingPCIID = interestingArray[2].trim().split(":");
// If we have Chipset line, we should parse it as well and
// add to the button
if (interestingLineArr.length > 1) {
var PCIid = (interestingPCIID[0] + "," + interestingPCIID[1]).
toUpperCase();
// Nvidia driver provides good code in the Chipset line
if (interestingPCIID[0].toLowerCase() == "10de") {
cardStr = interestingLineArr[1][2].
replace(/\s*nvidia\s*/ig,"").
replace('"','','g');
} else {
try {
cardStr = constantData.chipNames[PCIid][0];
} catch (e if e instanceof TypeError) {
PCIid = PCIid.toLowerCase().replace(",",":");
cardStr = null;
alert("PCI ID " + PCIid + " is not known!");
self.postMessage(new Message("SetClipboard", PCIid.toString()));
} catch (e) {
throw e;
}
}
}
else {
cardStr = null;
}
if (cardStr) {
createNewButton("short_desc_nonedit_display", false, {
"name": "Fill In",
"chipMagic": cardStr
});
}
}
}
}
function analyzeXorg(results) {
var innerString = "";
if (results.length > 0) {
results.splice(0, 1); // remove headers
results.sort();
results.forEach(function(lRE) {
innerString += lRE.input + "<br>\n";
});
innerString += "----------<br>\n" +
results.length + " interesting lines found.";
}
else {
innerString += "No matching lines found!";
}
self.postMessage(new Message("OpenStringInPanel",
'<!DOCTYPE html PUBLIC "-//IETF//DTD HTML 2.0//EN">' +
"<html><head><title>Xorg.0.log analysis</title></head><body><pre>\n" +
innerString.trim() +
"\n</pre></body></html>"));
}
function analyzeXorgLog(attachID, backMsg) {
self.postMessage(new Message("GetURL", {
url: "https://" + window.location.hostname + "/attachment.cgi?id=" + attachID,
backMessage: backMsg
}));
}
function findInterestingLine(wholeLog, backMsg) {
var REstr = logAnalyzeLogic[backMsg].re;
var REarr = [];
if (typeof REstr == "string") {
REarr = [new RegExp(REstr)];
}
else if (Array.isArray(REstr)) {
REarr = REstr.map(function (reone) {
return new RegExp(reone);
});
}
console.myDebug("Current REs:");
REarr.forEach(function (re) {
console.myDebug("re: " + re.source);
});
var results = [];
wholeLog.split("\n").
forEach(function(line) {
REarr.forEach(function (re, reIdx) {
if (re.test(line)) {
console.myDebug("Found match on line:\n" + line);
console.myDebug("Result: " + re.exec(line).toSource());
results.push(re.exec(line));
}
});
});
console.myDebug("results = " + results.toSource());
logAnalyzeLogic[backMsg].func(results);
}
/**
* Add information about the upstream bug upstream, and closing it.
*
* @param evt
* Event which called this handler
* @return none
*/
function addClosingUpstream() {
var refs = document.getElementById("external_bugs_table")
.getElementsByTagName("tr");
// that's a bad id, if there is a one. :)
var inputBox = document.getElementById("inputbox");
var externalBugID = 0;
var wholeURL = "";
// Fix missing ID on the external_id SELECT
document.getElementsByName("external_id")[0].setAttribute("id",
"external_id");
if (inputBox.value.match(/^http.*/)) {
wholeURL = inputBox.value;
// TODO this is probably midlly ineffective ... we do parseURL here,
// and getBugNoFromURL does it as well.
externalBugID = getBugNoFromURL(wholeURL);
if (externalBugID) {
inputBox.value = externalBugID;
}
// get bugzillaName and set the label
var bugzillaName = getBugzillaName(parseURL(wholeURL).host,
constantData.bugzillaLabelNames);
selectOptionByLabel("external_id", bugzillaName);
}
else if (!isNaN(inputBox.value)) {
externalBugID = parseInt(inputBox.value, 10);
var bugzillaHostname = document.getElementById("external_id").value;
wholeURL = bugzillaHostname+"show_bug.cgi?id="+externalBugID;
}
else {
// no inputBox.value -- maybe there is an external bug from
// the previous commit?
}
// It is not good to close bug as UPSTREAM, if there is no reference
// to the upstream bug.
if ((externalBugID > 0) || (refs.length > 2)) {
var msgStr = constantData.commentStrings.sentUpstreamString;
msgStr = msgStr.replace("§§§", wholeURL);
centralCommandDispatch("comment",msgStr);
centralCommandDispatch("status", "CLOSED");
centralCommandDispatch("resolution", "UPSTREAM");
}
else {
console.myDebug("No external bug specified among the External References!");
}
}
/**
*
*/
function parseBacktrace (ret) {
var signalHandler = new RegExp("^\\s*#[0-9]*\\s*<signal handler called>");
var frameNo = new RegExp("^\\s*#([0-9]*)\\s");
var splitArray = ret.split("\n");
var i = 0, ii = splitArray.length;
var outStr = "", curLine = "", numStr = "";
var lineCounter = 0, endLineNo = 0;
// TODO shouldn't we just cut off and analyze whole thread?
while (i < ii) {
if (signalHandler.test(splitArray[i])) {
break;
}
i++;
}
if (i < ii) {
lineCounter = parseInt(frameNo.exec(splitArray[i])[1], 10);
endLineNo = lineCounter + NumberOfFrames;
curLine = splitArray[i];
while ((lineCounter < endLineNo) && (curLine.trim().length > 0)
&& (i < ii)) {
outStr += curLine + '\n';
numStr = frameNo.exec(curLine);
if (numStr) {
lineCounter = parseInt(numStr[1], 10);
}
i++;
curLine = splitArray[i];
}
return outStr;
}
return "";
}
function RHBZinit(attachments) {
// inheritance ... call superobject's constructor
var AbrtRE = new RegExp("^\\s*\\[abrt\\]");
var btSnippet = "";
var chipMagicInterestingLine = "";
// getBadAttachments
var XorgLogAttList = [];
var XorgLogAttListIndex = 0;
markBadAttachments(attachments);
var parsedAttachments = attachments.filter(function (att) {
return (new RegExp(titleParsedAttachment).test(att[0]));
});
if (constantData.defaultAssignee) {
setDefaultAssignee();
}
if (constantData.xorgBugsCategories) {
var XBZlist = filterByRegexp(constantData.
xorgBugsCategories, getComponent());
if (XBZlist) {
makeBugCategoriesList(XBZlist);
}
}
// setup logging only when we ask for it
if (config.submitsLogging && (window.location.hostname == "bugzilla.redhat.com")) {
setUpLogging();
}
// Dig out backtrace protection against double-firing?
btSnippet = "";
var parseAbrtBacktraces = config.parseAbrtBacktraces;
if (parseAbrtBacktraces && AbrtRE.test(getSummary())) {
pasteBacktraceInComments(parsedAttachments);
}
// Find out Xorg.0.log attachment URL
XorgLogAttList = attachments.filter(function (value) {
// Xorg.0.log must be text, otherwise we cannot parse it
return (/[xX].*log/.test(value[0]) && /text/.test(value[2]));
});
// Just add a link to every Xorg.0.log link analyzing it.
addCheckXorgLogLink(XorgLogAttList);
setBranding(XorgLogAttList);
// Don't allow to submit a page which would change the bug to 0xFFFF component
document.forms.namedItem("changeform").addEventListener(
"submit", function(aEvt) {
if (getComponent() == "0xFFFF") {
alert("Don't change the component to 0xFFFF");
aEvt.stopPropagation();
aEvt.preventDefault();
}
}, false);
// Uncheck "set default assignee" when the assignee is changed by other means
document.getElementById("assigned_to").addEventListener("change",
function() {
changeAssignee(null);
}, false);
}
