[Predator] Pass config as argument to findit.

appengine/findit/crash/findit.py

 # Copyright 2016 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.
 
 import copy
 import json
 import logging
 
 from google.appengine.ext import ndb
 
 from common import appengine_util
 from common.chrome_dependency_fetcher import ChromeDependencyFetcher
 from common import constants
+from crash.component import Component
+from crash.component_classifier import ComponentClassifier
 from crash.crash_report import CrashReport
+from crash.project import Project
+from crash.project_classifier import ProjectClassifier
 from libs import time_util
 from model import analysis_status
 from model.crash.crash_config import CrashConfig
 
 
 # TODO(http://crbug.com/659346): since most of our unit tests are
 # FinditForFracas-specific, wrengr moved them to findit_for_chromecrash_test.py.
 # However, now we're missing coverage for most of this file (due to the
 # buggy way coverage is computed). Need to add a bunch of new unittests
 # to get coverage back up.
 
 # TODO: this class depends on ndb stuff, and should therefore move to
 # cr-culprit-finder/service/predator as part of the big reorganization.
 # This class should be renamed to avoid confustion between Findit and Predator.
 # Think of a good name (e.g.'PredatorApp') for this class.
 class Findit(object):
 
-  def __init__(self, get_repository):
+  def __init__(self, get_repository, config):
     """
     Args:
       get_repository (callable): a function from DEP urls to ``Repository``
         objects, so we can get changelogs and blame for each dep. Notably,
         to keep the code here generic, we make no assumptions about
         which subclass of ``Repository`` this function returns. Thus,
         it is up to the caller to decide what class to return and handle
         any other arguments that class may require (e.g., an http client
         for ``GitilesRepository``).
+      config (ndb.CrashConfig): Config for clients and project and component
+        classifiers.
     """
     self._get_repository = get_repository
     self._dep_fetcher = ChromeDependencyFetcher(get_repository)
+
+    # The top_n is the number of frames we want to check to get project
+    # classifications.
+    projects = [Project(name, path_regexs, function_regexs, host_directories)
+                for name, path_regexs, function_regexs, host_directories
+                in config.project_classifier['project_path_function_hosts']]
+    self._project_classifier = ProjectClassifier(
+        projects, config.project_classifier['top_n'],
+        config.project_classifier['non_chromium_project_rank_priority'])
+
+    components = [Component(component_name, path_regex, function_regex)
+                  for path_regex, function_regex, component_name
+                  in config.component_classifier['path_function_component']]
+    self._component_classifier = ComponentClassifier(
+        components, config.component_classifier['top_n'])
+
+    self._config = config
+
     # TODO(http://crbug.com/659354): because self.client is volatile,
     # we need some way of updating the Predator instance whenever the
     # config changes. How to do that cleanly?
     self._predator = None
     self._stacktrace_parser = None
 
   # This is a class method because it should be the same for all
   # instances of this class. We can in fact call class methods on
   # instances (not just on the class itself), so we could in principle
   # get by with just this method. However, a @classmethod is treated
@@ skipping 25 matching lines @@
 
     N.B., this property is static and should not be overridden."""
     return self._ClientID()
 
   # TODO(http://crbug.com/659354): can we remove the dependency on
   # CrashConfig entirely? It'd be better to receive method calls
   # whenever things change, so that we know the change happened (and
   # what in particular changed) so that we can update our internal state
   # as appropriate.
   @property
-  def config(self):
+  def client_config(self):
     """Get the current value of the client config for the class of this object.
 
     N.B., this property is volatile and may change asynchronously.
 
     If the event of an error this method will return ``None``. That we do
     not return the empty dict is intentional. All of the circumstances
     which would lead to this method returning ``None`` indicate
     underlying bugs in code elsewhere. (E.g., creating instances of
     abstract classes, implementing a subclass which is not suppported by
     ``CrashConfig``, etc.) Because we return ``None``, any subsequent
     calls to ``__getitem__`` or ``get`` will raise method-missing errors;
     which serve to highlight the underlying bug. Whereas, if we silently
     returned the empty dict, then calls to ``get`` would "work" just
     fine; thereby masking the underlying bug!
     """
-    return CrashConfig.Get().GetClientConfig(self.client_id)
+    return self._config.GetClientConfig(self.client_id)
 
   # TODO(http://crbug.com/644476): rename to CanonicalizePlatform or
   # something like that.
   def RenamePlatform(self, platform):
     """Remap the platform to a different one, based on the config."""
     # TODO(katesonia): Remove the default value after adding validity check to
     # config.
-    return self.config.get('platform_rename', {}).get(platform, platform)
+    return self.client_config.get('platform_rename', {}).get(platform, platform)
 
   def CheckPolicy(self, crash_data): # pylint: disable=W0613
     """Check whether this client supports analyzing the given report.
 
     Some clients only support analysis for crashes on certain platforms
     or channels, etc. This method checks to see whether this client can
     analyze the given crash. The default implementation on the Findit
     base class returns None for everything, so that unsupported clients
     reject everything, as expected.
 
@@ skipping 82 matching lines @@
   def ParseStacktrace(self, model): # pragma: no cover
     """Parse a CrashAnalysis's ``stack_trace`` string into a Stacktrace object.
 
     Args:
       model (CrashAnalysis): The model containing the stack_trace string
         to be parsed.
 
     Returns:
       On success, returns a Stacktrace object; on failure, returns None.
     """
-    # Use up-to-date ``top_n`` in self.config to filter top n frames.
+    # Use up-to-date ``top_n`` in self.client_config to filter top n frames.
     stacktrace = self._stacktrace_parser.Parse(
         model.stack_trace,
         self._dep_fetcher.GetDependency(model.crashed_version, model.platform),
         model.signature,
-        self.config.get('top_n'))
+        self.client_config.get('top_n'))
     if not stacktrace:
       logging.warning('Failed to parse the stacktrace %s', model.stack_trace)
       return None
 
     return stacktrace
 
   def ProcessResultForPublishing(self, result, key):
     """Client specific processing of result data for publishing."""
     raise NotImplementedError()
 
@@ skipping 39 matching lines @@
     stacktrace = self.ParseStacktrace(model)
     if stacktrace is None:
       return None
 
     return self._predator.FindCulprit(CrashReport(
         crashed_version = model.crashed_version,
         signature = model.signature,
         platform = model.platform,
         stacktrace = stacktrace,
         regression_range = model.regression_range))