[Predator] Switch from anonymous dict to CrashData.

appengine/findit/crash/crash_pipeline.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 crash import monitoring
 
 from common import appengine_util
 from common import pubsub_util
 from common.pipeline_wrapper import BasePipeline
 from common.pipeline_wrapper import pipeline
 from crash import findit_for_chromecrash
 from crash import findit_for_clusterfuzz
 from crash.type_enums import CrashClient
 from libs import time_util
 from gae_libs.gitiles.cached_gitiles_repository import CachedGitilesRepository
 from gae_libs.http.http_client_appengine import HttpClientAppengine
 from model import analysis_status
+from model.crash.crash_config import CrashConfig
 
 
 # TODO(http://crbug.com/659346): write complete coverage tests for this.
-def FinditForClientID(client_id, get_repository): # pragma: no cover
+def FinditForClientID(client_id, get_repository, config): # pragma: no cover
   """Construct a Findit object from a client id string specifying the class.
 
   We cannot pass Findit objects to the various methods in
   ``crash.crash_pipeline``, because they are not JSON serializable. For
   now, we just serialize Findit objects as their ``client_id``, and then
   use this function to reconstruct them. Alas, this means we will lose
   various other information stored in the Findit object (i.e., stuff that
   comes from CrashConfig); which could lead to some hard-to-diagnose
   coherency bugs, since the new Findit object will be based on the
   CrashConfig at the time it's constructed, which may be different
   than the CrashConfig at the time the previous Findit object was
   constructed. In the future we should fix all this to serialize Findit
   objects in a more robust way.
   """
   assert isinstance(client_id, (str, unicode)), (
       'FinditForClientID: expected string or unicode, but got %s'
       % client_id.__class__.__name__)
   # TODO(wrengr): it'd be nice to replace this with a single lookup in
   # a dict; but that's buggy for some unknown reason.
   if client_id == CrashClient.FRACAS:
     cls = findit_for_chromecrash.FinditForFracas
   elif client_id == CrashClient.CRACAS: # pragma: no cover
     cls = findit_for_chromecrash.FinditForCracas
   elif client_id == CrashClient.CLUSTERFUZZ: # pragma: no cover
     cls = findit_for_clusterfuzz.FinditForClusterfuzz
   else: # pragma: no cover
     raise ValueError('FinditForClientID: '
         'unknown or unsupported client %s' % client_id)
 
-  return cls(get_repository)
+  return cls(get_repository, config)
 
 
 # Some notes about the classes below, for people who are not familiar
 # with AppEngine pipelines:
 #
 # The pipeline library is designed in a strange way which requires that
 # all the ``__init__`` and ``run`` methods in this file take the exact
 # same arguments. This arises from the interaction between a few
 # different constraints. First, for any given pipeline, its ``__init__``
 # and ``run`` must take the same arguments. Second, all the objects that
@@ skipping 20 matching lines @@
 # processes, so we'll actually end up reconstructing the ``Findit`` object
 # twice. This also means ``run`` can't store anything in the pipeline
 # object and expect it to still be available in the ``finalized`` method.
 
 class CrashBasePipeline(BasePipeline):
   def __init__(self, client_id, crash_identifiers):
     super(CrashBasePipeline, self).__init__(client_id, crash_identifiers)
     self._crash_identifiers = crash_identifiers
     self._findit = FinditForClientID(
         client_id,
-        CachedGitilesRepository.Factory(HttpClientAppengine()))
+        CachedGitilesRepository.Factory(HttpClientAppengine()),
+        CrashConfig.Get())
 
   @property
   def client_id(self): # pragma: no cover
     return self._findit.client_id
 
   def run(self, *args, **kwargs):
     raise NotImplementedError()
 
 
 class CrashAnalysisPipeline(CrashBasePipeline):
@@ skipping 25 matching lines @@
     analysis = self._findit.GetAnalysis(self._crash_identifiers)
 
     # Update the model's status to say we're in the process of doing analysis.
     analysis.pipeline_status_path = self.pipeline_status_path()
     analysis.status = analysis_status.RUNNING
     analysis.started_time = time_util.GetUTCNow()
     analysis.findit_version = appengine_util.GetCurrentVersion()
     analysis.put()
 
     # Actually do the analysis.
-    culprit = self._findit.FindCulprit(analysis)
+    culprit = self._findit.FindCulprit(analysis.ToCrashReport())
     if culprit is not None:
       result, tags = culprit.ToDicts()
     else:
       result = {'found': False}
       tags = {
           'found_suspects': False,
           'found_project': False,
           'found_components': False,
           'has_regression_range': False,
           'solution': None,
@@ skipping 76 matching lines @@
     N.B., due to the structure of AppEngine pipelines, this method must
     accept the same arguments as are passed to ``__init__``; however,
     because they were already passed to ``__init__`` there's no use in
     recieving them here. Thus, we discard all the arguments to this method
     (except for ``self``, naturally).
     """
     run_analysis = yield CrashAnalysisPipeline(
         self._client_id, self._crash_identifiers)
     with pipeline.After(run_analysis):
       yield PublishResultPipeline(self._client_id, self._crash_identifiers)