Remove support for legacy wpr_server in Telemetry

telemetry/telemetry/wpr/archive_info.py

 # Copyright 2013 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 json
 import logging
 import os
 import re
 import shutil
 import tempfile
@@ skipping 24 matching lines @@
     self._bucket = bucket
     self.temp_target_wpr_file_path = None
     # Ensure directory exists.
     if not os.path.exists(self._base_dir):
       os.makedirs(self._base_dir)
 
     assert data.get('platform_specific', False), (
         'Detected old version of archive info json file. Please update to new '
         'version.')
 
-    self.is_using_wpr_go_archives = True
     self._story_name_to_wpr_file = data['archives']
-    story_archives = self._data['archives']
-    for story in story_archives:
-      files = story_archives[story]
-      for f in files:
-        if files[f].endswith('.wpr'):
-          self.is_using_wpr_go_archives = False
-    self.ValidateArchivesFormat(story_archives)
-
-  @staticmethod
-  def ValidateArchivesFormat(story_archives):
-    """ Checks that all archives follow either .wpr format or .wprgo format
-    but not both.
-    """
-    using_wpr = False
-    using_wpr_go = False
-    for story in story_archives:
-      files = story_archives[story]
-      for f in files:
-        if files[f].endswith('.wprgo'):
-          using_wpr_go = True
-        elif files[f].endswith('.wpr'):
-          using_wpr = True
-        assert not(using_wpr and using_wpr_go), (
-            'Detected both .wprgo or .wpr archive format.')
 
   @classmethod
   def FromFile(cls, file_path, bucket):
     """ Generates an archive_info instance with the given json file. """
     if os.path.exists(file_path):
       with open(file_path, 'r') as f:
         data = json.load(f)
         return cls(file_path, data, bucket)
     return cls(file_path, {'archives': {}, 'platform_specific': True}, bucket)
 
@@ skipping 10 matching lines @@
     exists.
     """
     logging.info('Downloading WPR archives. This can take a long time.')
     start_time = time.time()
     # If no target platform is set, download all platforms.
     if target_platforms is None:
       target_platforms = _ALL_PLATFORMS
     else:
       assert isinstance(target_platforms, list), 'Must pass platforms as a list'
       target_platforms = target_platforms + [_DEFAULT_PLATFORM]
-    # Download all .wpr or .wprgo files.
+    # Download all .wprgo files.
     if not self._bucket:
       logging.warning('Story set in %s has no bucket specified, and '
                       'cannot be downloaded from cloud_storage.', )
       return
     assert 'archives' in self._data, ("Invalid data format in %s. 'archives' "
                                       "field is needed" % self._file_path)
 
     def download_if_needed(path):
       try:
         cloud_storage.GetIfChanged(path, self._bucket)
@@ skipping 97 matching lines @@
   def _WprFileNameToPath(self, wpr_file):
     return os.path.abspath(os.path.join(self._base_dir, wpr_file))
 
   def _NextWprFileName(self):
     """Creates a new file name for a wpr archive file."""
     # The names are of the format "some_thing_number.wpr" or
     # "some_thing_number.wprgo". Read the numbers.
     highest_number = -1
     base = None
     wpr_files = []
-    extension = 'wprgo' if self.is_using_wpr_go_archives else 'wpr'
+    extension = 'wprgo'
     for story in self._data['archives']:
       for p in self._data['archives'][story]:
         wpr_files.append(self._data['archives'][story][p])
 
     for wpr_file in wpr_files:
       pattern = r'(?P<BASE>.*)_(?P<NUMBER>[0-9]+).{extension}'.format(
           extension=extension)
       match = re.match(pattern, wpr_file)
       if not match:
         raise Exception('Illegal wpr file name ' + wpr_file)
       highest_number = max(int(match.groupdict()['NUMBER']), highest_number)
       if base and match.groupdict()['BASE'] != base:
         raise Exception('Illegal wpr file name ' + wpr_file +
                         ', doesn\'t begin with ' + base)
       base = match.groupdict()['BASE']
     if not base:
       # If we're creating a completely new info file, use the base name of the
       # story set file.
       base = os.path.splitext(os.path.basename(self._file_path))[0]
     new_filename = '%s_%03d.%s' % (base, highest_number + 1, extension)
     return new_filename, self._WprFileNameToPath(new_filename)
 
   def _SetWprFileForStory(self, story_name, wpr_file, target_platform):
     """For modifying the metadata when we're going to record a new archive."""
     if story_name not in self._data['archives']:
       # If there is no other recording we want the first to be the default
       # until a new default is recorded.
       self._data['archives'][story_name] = {_DEFAULT_PLATFORM: wpr_file}
     self._data['archives'][story_name][target_platform] = wpr_file