blob: 5e5494e6cd52d4682ebd4c59a86d64f508d2274a [file] [log] [blame]
# Copyright (c) 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
from threading import Lock
from common import utils
import crash_utils
class Blame(object):
"""Represents a blame object.
The object contains blame information for one line of stack, and this
information is shown when there are no CLs that change the crashing files.
line_content: The content of the line to find the blame for.
component_name: The name of the component for this line.
stack_frame_index: The stack frame index of this file.
file_name: The name of the file.
line_number: The line that caused a crash.
author: The author of this line on the latest revision.
revision: The latest revision of this line before the crash revision.
message: The commit message for the revision.
time: When the revision was committed.
url: The url of the change for the revision.
range_start: The starting range of the regression for this component.
range_end: The ending range of the regression.
def __init__(self, line_content, component_name, stack_frame_index,
file_name, line_number, author, revision, message, time,
url, range_start, range_end):
# Set all the variables from the arguments.
self.line_content = line_content
self.component_name = component_name
self.stack_frame_index = stack_frame_index
self.file = file_name
self.line_number = line_number = author
self.revision = revision
self.message = message
self.time = time
self.url = url
self.range_start = range_start
self.range_end = range_end
class BlameList(object):
"""Represents a list of blame objects.
def __init__(self):
self.blame_list = []
self.blame_list_lock = Lock()
def __getitem__(self, index):
return self.blame_list[index]
def FindBlame(self, callstack, component_to_crash_revision_dict,
component_to_regression_dict, parsers,
"""Given a stack within a stacktrace, retrieves blame information.
Only either first 'top_n_frames' or the length of stack, whichever is
shorter, results are returned. The default value of 'top_n_frames' is 10.
callstack: The list of stack frames.
component_to_crash_revision_dict: A dictionary that maps component to its
crash revision.
component_to_regression_dict: A dictionary that maps component to its
revision range.
parsers: A list of two parsers, svn_parser and git_parser
top_n_frames: A number of stack frames to show the blame result for.
# Only return blame information for first 'top_n_frames' frames.
stack_frames = callstack.GetTopNFrames(top_n_frames)
tasks = []
# Iterate through frames in stack.
for stack_frame in stack_frames:
# If the component this line is from does not have a crash revision,
# it is not possible to get blame information, so ignore this line.
component_path = stack_frame.component_path
if component_path not in component_to_crash_revision_dict:
crash_revision = component_to_crash_revision_dict[
range_start = None
range_end = None
repository_type = crash_utils.GetRepositoryType(crash_revision)
repository_parser = parsers[repository_type]
# If the revision is in SVN, and if regression information is available,
# get it. For Git, we cannot know the ordering between hash numbers.
if repository_type == 'svn':
if component_to_regression_dict and \
component_path in component_to_regression_dict:
component_object = component_to_regression_dict[component_path]
range_start = int(component_object['old_revision'])
range_end = int(component_object['new_revision'])
# Create a task to generate blame entry.
'function': self.__GenerateBlameEntry,
'args': [repository_parser, stack_frame, crash_revision,
range_start, range_end]})
# Run all the tasks.
def __GenerateBlameEntry(self, repository_parser, stack_frame,
crash_revision, range_start, range_end):
"""Generates blame list from the arguments."""
stack_frame_index = stack_frame.index
component_path = stack_frame.component_path
component_name = stack_frame.component_name
file_name = stack_frame.file_name
file_path = stack_frame.file_path
crashed_line_number = stack_frame.crashed_line_range[0]
if file_path.startswith(component_path):
file_path = file_path[len(component_path):]
# Parse blame information.
parsed_blame_info = repository_parser.ParseBlameInfo(
component_path, file_path, crashed_line_number, crash_revision)
# If it fails to retrieve information, do not do anything.
if not parsed_blame_info:
# Create blame object from the parsed info and add it to the list.
(line_content, revision, author, url, message, time) = parsed_blame_info
blame = Blame(line_content, component_name, stack_frame_index, file_name,
crashed_line_number, author, revision, message, time, url,
range_start, range_end)
with self.blame_list_lock:
def FilterAndSortBlameList(self):
"""Filters and sorts the blame list."""
# Sort the blame list by its position in stack.
self.blame_list.sort(key=lambda blame: blame.stack_frame_index)
filtered_blame_list = []
for blame in self.blame_list:
# If regression information is available, check if it needs to be
# filtered.
if blame.range_start and blame.range_end:
# Discards results that are after the end of regression.
if not utils.IsGitHash(blame.revision) and (
int(blame.range_end) <= int(blame.revision)):
self.blame_list = filtered_blame_list