diff options
Diffstat (limited to 'toolkit/crashreporter/CrashSubmit.sys.mjs')
| -rw-r--r-- | toolkit/crashreporter/CrashSubmit.sys.mjs | 666 |
1 files changed, 666 insertions, 0 deletions
diff --git a/toolkit/crashreporter/CrashSubmit.sys.mjs b/toolkit/crashreporter/CrashSubmit.sys.mjs new file mode 100644 index 0000000000..28647c5a83 --- /dev/null +++ b/toolkit/crashreporter/CrashSubmit.sys.mjs @@ -0,0 +1,666 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +import { FileUtils } from "resource://gre/modules/FileUtils.sys.mjs"; + +const SUCCESS = "success"; +const FAILED = "failed"; +const SUBMITTING = "submitting"; + +const UUID_REGEX = + /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i; +const SUBMISSION_REGEX = + /^bp-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i; + +// TODO: this is still synchronous; need an async INI parser to make it async +function parseINIStrings(path) { + let file = new FileUtils.File(path); + let factory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"].getService( + Ci.nsIINIParserFactory + ); + let parser = factory.createINIParser(file); + let obj = {}; + for (let key of parser.getKeys("Strings")) { + obj[key] = parser.getString("Strings", key); + } + return obj; +} + +// Since we're basically re-implementing (with async) part of the crashreporter +// client here, we'll just steal the strings we need from crashreporter.ini +async function getL10nStrings() { + let path = PathUtils.join( + Services.dirsvc.get("GreD", Ci.nsIFile).path, + "crashreporter.ini" + ); + let pathExists = await IOUtils.exists(path); + + if (!pathExists) { + // we if we're on a mac + let parentDir = PathUtils.parent(path); + path = PathUtils.join( + parentDir, + "MacOS", + "crashreporter.app", + "Contents", + "Resources", + "crashreporter.ini" + ); + + let pathExists = await IOUtils.exists(path); + + if (!pathExists) { + // This happens on Android where everything is in an APK. + // Android users can't see the contents of the submitted files + // anyway, so just hardcode some fallback strings. + return { + crashid: "Crash ID: %s", + reporturl: "You can view details of this crash at %s", + }; + } + } + + let crstrings = parseINIStrings(path); + let strings = { + crashid: crstrings.CrashID, + reporturl: crstrings.CrashDetailsURL, + }; + + path = PathUtils.join( + Services.dirsvc.get("XCurProcD", Ci.nsIFile).path, + "crashreporter-override.ini" + ); + pathExists = await IOUtils.exists(path); + + if (pathExists) { + crstrings = parseINIStrings(path); + + if ("CrashID" in crstrings) { + strings.crashid = crstrings.CrashID; + } + + if ("CrashDetailsURL" in crstrings) { + strings.reporturl = crstrings.CrashDetailsURL; + } + } + + return strings; +} + +function getDir(name) { + let uAppDataPath = Services.dirsvc.get("UAppData", Ci.nsIFile).path; + return PathUtils.join(uAppDataPath, "Crash Reports", name); +} + +async function writeFileAsync(dirName, fileName, data) { + let dirPath = getDir(dirName); + let filePath = PathUtils.join(dirPath, fileName); + await IOUtils.makeDirectory(dirPath, { permissions: 0o700 }); + await IOUtils.writeUTF8(filePath, data); +} + +function getPendingMinidump(id) { + let pendingDir = getDir("pending"); + + return [".dmp", ".extra", ".memory.json.gz"].map(suffix => { + return PathUtils.join(pendingDir, `${id}${suffix}`); + }); +} + +async function writeSubmittedReportAsync(crashID, viewURL) { + let strings = await getL10nStrings(); + let data = strings.crashid.replace("%s", crashID); + + if (viewURL) { + data += "\n" + strings.reporturl.replace("%s", viewURL); + } + + await writeFileAsync("submitted", `${crashID}.txt`, data); +} + +// the Submitter class represents an individual submission. +function Submitter(id, recordSubmission, noThrottle, extraExtraKeyVals) { + this.id = id; + this.recordSubmission = recordSubmission; + this.noThrottle = noThrottle; + this.additionalDumps = []; + this.extraKeyVals = extraExtraKeyVals; + // mimic deferred Promise behavior + this.submitStatusPromise = new Promise((resolve, reject) => { + this.resolveSubmitStatusPromise = resolve; + this.rejectSubmitStatusPromise = reject; + }); +} + +Submitter.prototype = { + submitSuccess: async function Submitter_submitSuccess(ret) { + // Write out the details file to submitted + await writeSubmittedReportAsync(ret.CrashID, ret.ViewURL); + + try { + let toDelete = [this.dump, this.extra]; + + if (this.memory) { + toDelete.push(this.memory); + } + + for (let entry of this.additionalDumps) { + toDelete.push(entry.dump); + } + + await Promise.all( + toDelete.map(path => { + return IOUtils.remove(path, { ignoreAbsent: true }); + }) + ); + } catch (ex) { + console.error(ex); + } + + this.notifyStatus(SUCCESS, ret); + this.cleanup(); + }, + + cleanup: function Submitter_cleanup() { + // drop some references just to be nice + this.iframe = null; + this.dump = null; + this.extra = null; + this.memory = null; + this.additionalDumps = null; + // remove this object from the list of active submissions + let idx = CrashSubmit._activeSubmissions.indexOf(this); + if (idx != -1) { + CrashSubmit._activeSubmissions.splice(idx, 1); + } + }, + + parseResponse: function Submitter_parseResponse(response) { + let parsedResponse = {}; + + for (let line of response.split("\n")) { + let data = line.split("="); + + if ( + (data.length == 2 && + data[0] == "CrashID" && + SUBMISSION_REGEX.test(data[1])) || + data[0] == "ViewURL" + ) { + parsedResponse[data[0]] = data[1]; + } + } + + return parsedResponse; + }, + + submitForm: function Submitter_submitForm() { + if (!("ServerURL" in this.extraKeyVals)) { + return false; + } + let serverURL = this.extraKeyVals.ServerURL; + delete this.extraKeyVals.ServerURL; + + // Override the submission URL from the environment + let envOverride = Services.env.get("MOZ_CRASHREPORTER_URL"); + if (envOverride != "") { + serverURL = envOverride; + } + + let xhr = new XMLHttpRequest(); + xhr.open("POST", serverURL, true); + + let formData = new FormData(); + + // tell the server not to throttle this if requested + this.extraKeyVals.Throttleable = this.noThrottle ? "0" : "1"; + + // add the data + let payload = Object.assign({}, this.extraKeyVals); + let json = new Blob([JSON.stringify(payload)], { + type: "application/json", + }); + formData.append("extra", json); + + // add the minidumps + let promises = [ + File.createFromFileName(this.dump, { + type: "application/octet-stream", + }).then(file => { + formData.append("upload_file_minidump", file); + }), + ]; + + if (this.memory) { + promises.push( + File.createFromFileName(this.memory, { + type: "application/gzip", + }).then(file => { + formData.append("memory_report", file); + }) + ); + } + + if (this.additionalDumps.length) { + let names = []; + for (let i of this.additionalDumps) { + names.push(i.name); + promises.push( + File.createFromFileName(i.dump, { + type: "application/octet-stream", + }).then(file => { + formData.append("upload_file_minidump_" + i.name, file); + }) + ); + } + } + + let manager = Services.crashmanager; + let submissionID = manager.generateSubmissionID(); + + xhr.addEventListener("readystatechange", evt => { + if (xhr.readyState == 4) { + let ret = + xhr.status === 200 ? this.parseResponse(xhr.responseText) : {}; + let submitted = !!ret.CrashID; + let p = Promise.resolve(); + + if (this.recordSubmission) { + let result = submitted + ? manager.SUBMISSION_RESULT_OK + : manager.SUBMISSION_RESULT_FAILED; + p = manager.addSubmissionResult( + this.id, + submissionID, + new Date(), + result + ); + if (submitted) { + manager.setRemoteCrashID(this.id, ret.CrashID); + } + } + + p.then(() => { + if (submitted) { + this.submitSuccess(ret); + } else { + this.notifyStatus(FAILED); + this.cleanup(); + } + }); + } + }); + + let p = Promise.all(promises); + let id = this.id; + + if (this.recordSubmission) { + p = p.then(() => { + return manager.addSubmissionAttempt(id, submissionID, new Date()); + }); + } + p.then(() => { + xhr.send(formData); + }); + return true; + }, + + notifyStatus: function Submitter_notify(status, ret) { + let propBag = Cc["@mozilla.org/hash-property-bag;1"].createInstance( + Ci.nsIWritablePropertyBag2 + ); + propBag.setPropertyAsAString("minidumpID", this.id); + if (status == SUCCESS) { + propBag.setPropertyAsAString("serverCrashID", ret.CrashID); + } + + let extraKeyValsBag = Cc["@mozilla.org/hash-property-bag;1"].createInstance( + Ci.nsIWritablePropertyBag2 + ); + for (let key in this.extraKeyVals) { + extraKeyValsBag.setPropertyAsAString(key, this.extraKeyVals[key]); + } + propBag.setPropertyAsInterface("extra", extraKeyValsBag); + + Services.obs.notifyObservers(propBag, "crash-report-status", status); + + switch (status) { + case SUCCESS: + this.resolveSubmitStatusPromise(ret.CrashID); + break; + case FAILED: + this.rejectSubmitStatusPromise(FAILED); + break; + default: + // no callbacks invoked. + } + }, + + readAnnotations: async function Submitter_readAnnotations(extra) { + // These annotations are used only by the crash reporter client and should + // not be submitted to Socorro. + const strippedAnnotations = [ + "StackTraces", + "TelemetryClientId", + "TelemetrySessionId", + "TelemetryServerURL", + ]; + let extraKeyVals = await IOUtils.readJSON(extra); + + this.extraKeyVals = { ...extraKeyVals, ...this.extraKeyVals }; + strippedAnnotations.forEach(key => delete this.extraKeyVals[key]); + }, + + submit: async function Submitter_submit() { + if (this.recordSubmission) { + await Services.crashmanager.ensureCrashIsPresent(this.id); + } + + let [dump, extra, memory] = getPendingMinidump(this.id); + let [dumpExists, extraExists, memoryExists] = await Promise.all([ + IOUtils.exists(dump), + IOUtils.exists(extra), + IOUtils.exists(memory), + ]); + + if (!dumpExists || !extraExists) { + this.notifyStatus(FAILED); + this.cleanup(); + return this.submitStatusPromise; + } + + this.dump = dump; + this.extra = extra; + this.memory = memoryExists ? memory : null; + await this.readAnnotations(extra); + + let additionalDumps = []; + + if ("additional_minidumps" in this.extraKeyVals) { + let dumpsExistsPromises = []; + let names = this.extraKeyVals.additional_minidumps.split(","); + + for (let name of names) { + let [dump /* , extra, memory */] = getPendingMinidump( + this.id + "-" + name + ); + + dumpsExistsPromises.push(IOUtils.exists(dump)); + additionalDumps.push({ name, dump }); + } + + let dumpsExist = await Promise.all(dumpsExistsPromises); + let allDumpsExist = dumpsExist.every(exists => exists); + + if (!allDumpsExist) { + this.notifyStatus(FAILED); + this.cleanup(); + return this.submitStatusPromise; + } + } + + this.notifyStatus(SUBMITTING); + this.additionalDumps = additionalDumps; + + if (!(await this.submitForm())) { + this.notifyStatus(FAILED); + this.cleanup(); + } + + return this.submitStatusPromise; + }, +}; + +// =================================== +// External API goes here +export var CrashSubmit = { + // A set of strings representing how a user subnmitted a given crash + SUBMITTED_FROM_AUTO: "Auto", + SUBMITTED_FROM_INFOBAR: "Infobar", + SUBMITTED_FROM_ABOUT_CRASHES: "AboutCrashes", + SUBMITTED_FROM_CRASH_TAB: "CrashedTab", + + /** + * Submit the crash report named id.dmp from the "pending" directory. + * + * @param id + * Filename (minus .dmp extension) of the minidump to submit. + * @param submittedFrom + * One of the SUBMITTED_FROM_* constants representing how the + * user submitted this crash. + * @param params + * An object containing any of the following optional parameters: + * - recordSubmission + * If true, a submission event is recorded in CrashManager. + * - noThrottle + * If true, this crash report should be submitted with + * the Throttleable annotation set to "0" indicating that + * it should be processed right away. This should be set + * when the report is being submitted and the user expects + * to see the results immediately. Defaults to false. + * - extraExtraKeyVals + * An object whose key-value pairs will be merged with the data from + * the ".extra" file submitted with the report. The properties of + * this object will override properties of the same name in the + * .extra file. + * + * @return a Promise that is fulfilled with the server crash ID when the + * submission succeeds and rejected otherwise. + */ + submit: function CrashSubmit_submit(id, submittedFrom, params) { + params = params || {}; + let recordSubmission = false; + let noThrottle = false; + let extraExtraKeyVals = {}; + + if ("recordSubmission" in params) { + recordSubmission = params.recordSubmission; + } + + if ("noThrottle" in params) { + noThrottle = params.noThrottle; + } + + if ("extraExtraKeyVals" in params) { + extraExtraKeyVals = params.extraExtraKeyVals; + } + + extraExtraKeyVals.SubmittedFrom = submittedFrom; + + let submitter = new Submitter( + id, + recordSubmission, + noThrottle, + extraExtraKeyVals + ); + CrashSubmit._activeSubmissions.push(submitter); + return submitter.submit(); + }, + + /** + * Delete the minidup from the "pending" directory. + * + * @param id + * Filename (minus .dmp extension) of the minidump to delete. + * + * @return a Promise that is fulfilled when the minidump is deleted and + * rejected otherwise + */ + delete: async function CrashSubmit_delete(id) { + await Promise.all( + getPendingMinidump(id).map(path => { + return IOUtils.remove(path); + }) + ); + }, + + /** + * Add a .dmg.ignore file along side the .dmp file to indicate that the user + * shouldn't be prompted to submit this crash report again. + * + * @param id + * Filename (minus .dmp extension) of the report to ignore + * + * @return a Promise that is fulfilled when (if) the .dmg.ignore is created + * and rejected otherwise. + */ + ignore: async function CrashSubmit_ignore(id) { + let [dump /* , extra, memory */] = getPendingMinidump(id); + const ignorePath = `${dump}.ignore`; + await IOUtils.writeUTF8(ignorePath, "", { mode: "create" }); + }, + + /** + * Get the list of pending crash IDs, excluding those marked to be ignored + * @param minFileDate + * A Date object. Any files last modified before that date will be ignored + * + * @return a Promise that is fulfilled with an array of string, each + * being an ID as expected to be passed to submit() or ignore() + */ + pendingIDs: async function CrashSubmit_pendingIDs(minFileDate) { + let ids = []; + let pendingDir = getDir("pending"); + + if (!(await IOUtils.exists(pendingDir))) { + return ids; + } + + let children; + try { + children = await IOUtils.getChildren(pendingDir); + } catch (ex) { + console.error(ex); + throw ex; + } + + try { + const entries = Object.create(null); + const ignored = Object.create(null); + + for (const child of children) { + const info = await IOUtils.stat(child); + + if (info.type !== "directory") { + const name = PathUtils.filename(child); + const matches = name.match(/(.+)\.dmp$/); + if (matches) { + const id = matches[1]; + + if (UUID_REGEX.test(id)) { + entries[id] = info; + } + } else { + // maybe it's a .ignore file + const matchesIgnore = name.match(/(.+)\.dmp.ignore$/); + if (matchesIgnore) { + const id = matchesIgnore[1]; + + if (UUID_REGEX.test(id)) { + ignored[id] = true; + } + } + } + } + } + + for (const [id, info] of Object.entries(entries)) { + const accessDate = new Date(info.lastAccessed); + if (!(id in ignored) && accessDate > minFileDate) { + ids.push(id); + } + } + } catch (ex) { + console.error(ex); + throw ex; + } + + return ids; + }, + + /** + * Prune the saved dumps. + * + * @return a Promise that is fulfilled when the daved dumps are deleted and + * rejected otherwise + */ + pruneSavedDumps: async function CrashSubmit_pruneSavedDumps() { + const KEEP = 10; + + let dirEntries = []; + let pendingDir = getDir("pending"); + + let children; + try { + children = await IOUtils.getChildren(pendingDir); + } catch (ex) { + if (DOMException.isInstance(ex) && ex.name === "NotFoundError") { + return []; + } + + throw ex; + } + + for (const path of children) { + let infoPromise; + try { + infoPromise = IOUtils.stat(path); + } catch (ex) { + console.error(ex); + throw ex; + } + + const name = PathUtils.filename(path); + + if (name.match(/(.+)\.extra$/)) { + dirEntries.push({ + name, + path, + infoPromise, + }); + } + } + + dirEntries.sort(async (a, b) => { + let dateA = (await a.infoPromise).lastModified; + let dateB = (await b.infoPromise).lastModified; + + if (dateA < dateB) { + return -1; + } + + if (dateB < dateA) { + return 1; + } + + return 0; + }); + + if (dirEntries.length > KEEP) { + let toDelete = []; + + for (let i = 0; i < dirEntries.length - KEEP; ++i) { + let extra = dirEntries[i]; + let matches = extra.leafName.match(/(.+)\.extra$/); + + if (matches) { + let pathComponents = PathUtils.split(extra.path); + pathComponents[pathComponents.length - 1] = matches[1]; + let path = PathUtils.join(...pathComponents); + + toDelete.push(extra.path, `${path}.dmp`, `${path}.memory.json.gz`); + } + } + + await Promise.all( + toDelete.map(path => { + return IOUtils.remove(path, { ignoreAbsent: true }); + }) + ); + } + }, + + // List of currently active submit objects + _activeSubmissions: [], +}; |