[LNT] Python 3 support: use Python 3 urllib

[thopre]

Summary

Adapt imports to urllib and urllib2 to rely on Python 3 module
organization by installing them as aliases. This was produced by running
futurize's stage2 libfuturize.fixes.fix_future_standard_library_urllib
and adapted manually to remove excess import and fix up str to byte
conversion of urlencode result.

[hubert.reinterpretcast]

lnt/util/ServerUtil.py

45

I think .encode(encoding='ascii') makes it more clear that the Python 2 and Python 3 behavior of this is not going to diverge.

[thopre]

Encode URL in ascii for real compability with Python2

[hubert.reinterpretcast]

LGTM.

[thopre]

Rebase earlier in the patch series since it's already approved

[thopre]

Committed as 290cda8c5df56cad8a5654a5fe6c48fcf7fc7158

lnt/lnttool/viewcomparison.py

+from future import standard_library
+standard_library.install_aliases()
 import click
 import time
-import urllib
+import urllib.request
 import webbrowser
 import sys
 
 
 def _start_browser(url, debug=False):
     from lnt.util import logger
 
     def url_is_up(url):
         try:
-            o = urllib.urlopen(url)
+            o = urllib.request.urlopen(url)
         except IOError:
             return False
         o.close()
         return True
 
     # Wait for server to start...
     if debug:
         logger.info('waiting for server to start...')

lnt/server/reporting/dailyreport.py

+from future import standard_library
+standard_library.install_aliases()
 from lnt.server.reporting.analysis import REGRESSED, UNCHANGED_FAIL
 from lnt.server.reporting.report import RunResult, RunResults, report_css_styles, pairs, OrderAndHistory
 from lnt.util import multidict
 import datetime
 import lnt.server.reporting.analysis
 import lnt.server.ui.app
 import re
 import sqlalchemy.sql
-import urllib
+import urllib.parse
 
 
 class DailyReport(object):
     def __init__(self, ts, year, month, day, num_prior_days_to_include=3,
                  day_start_offset_hours=16, for_mail=False,
                  filter_machine_regex=None):
         self.ts = ts
         self.hash_of_binary_field = self.ts.Sample.get_hash_of_binary_field()
def __init__(self, ts, year, month, day, num_prior_days_to_include=3,
         self.reporting_machines = None
         self.reporting_tests = None
         self.result_table = None
         self.nr_tests_table = None
 
     def get_query_parameters_string(self):
         query_params = [
             "{}={}".format(
-                urllib.quote_plus(query_param), urllib.quote_plus(str(value)))
+                urllib.parse.quote_plus(query_param), urllib.parse.quote_plus(str(value)))
             for query_param, value in (
                 ("day_start", self.day_start_offset.seconds // 3600),
                 ("num_days", self.num_prior_days_to_include),
                 ("filter-machine-regex", self.filter_machine_regex_str),)
             if value is not None]
         # Use & instead of plain & to make sure legal XML is
         # produced, so that the unit tests can parse the output using
         # python's built-in XML parser.

lnt/server/ui/filters.py

+from future import standard_library
+standard_library.install_aliases()
 import StringIO
 import datetime
 import pprint
-import urllib
+import urllib.parse
 import time
 
 from lnt.server.ui import util
 
 
 def filter_asutctime(time):
     ts = datetime.datetime.utcfromtimestamp(time)
     return ts.strftime('%Y-%m-%d %H:%M:%S UTC')

 def filter_format_or_default(fmt, input, default):
     if input:
         return fmt % input
     else:
         return default
 
 
 def filter_urlencode(args):
-    return urllib.urlencode(args)
+    return urllib.parse.urlencode(args)
 
 
 def filter_timedelta(start_time):
     return "%.2fs" % (time.time() - start_time)
 
 
 def filter_producerAsHTML(producer):
     if not producer:

lnt/tests/nt.py

 """LLVM test-suite compile and execution tests"""
 from __future__ import absolute_import
 from __future__ import print_function
+from future import standard_library
+standard_library.install_aliases()
 import csv
 import os
 import platform
 import re
 import shutil
 import subprocess
 import sys
 import glob
 import time
 import traceback
-import urllib2
+import urllib.error
 import shlex
 import pipes
 import resource
 
 import click
 
 import lnt.testing
 import lnt.testing.util.compilers
def submit_helper(self, config, merge_run=None):
         result = None
         if config.submit_url:
             from lnt.util import ServerUtil
             for server in config.submit_url:
                 self.log("submitting result to %r" % (server,))
                 try:
                     result = ServerUtil.submitFile(server, report_path, False,
                                                    merge_run=merge_run)
-                except (urllib2.HTTPError, urllib2.URLError) as e:
+                except (urllib.error.HTTPError, urllib.error.URLError) as e:
                     logger.warning("submitting to {} failed with {}"
                                    .format(server, e))
         else:
             # Simulate a submission to retrieve the results report.
             # Construct a temporary database and import the result.
             self.log("submitting result to dummy instance")
 
             import lnt.server.db.v4db

lnt/util/ServerUtil.py

 """
 Utility for submitting files to a web server over HTTP.
 """
 from __future__ import print_function
+from future import standard_library
+standard_library.install_aliases()
 import sys
-import urllib
-import urllib2
+import urllib.request
+import urllib.parse
+import urllib.error
 import contextlib
 import json
 
 import lnt.server.instance
 
 # FIXME: I used to maintain this file in such a way that it could be used
 # separate from LNT to do submission. This could be useful for adapting an
 # older system to report to LNT, for example. It might be nice to factor the
with open(file, 'rb') as f:
             'input_data': f.read(),
             'commit': "1",  # compatibility with old servers.
         }
         if select_machine is not None:
             values['select_machine'] = select_machine
         if merge_run is not None:
             values['merge'] = merge_run
     headers = {'Accept': 'application/json'}
-    data = urllib.urlencode(values)
+    data = urllib.parse.urlencode(values).encode(encoding='ascii')
     try:
-        response = urllib2.urlopen(urllib2.Request(url, data, headers=headers))
-    except urllib2.HTTPError as e:
+        response = urllib.request.urlopen(urllib.request.Request(url, data, headers=headers))
+    except urllib.error.HTTPError as e:
         _show_json_error(e.read())
         return
-    except urllib2.URLError as e:
+    except urllib.error.URLError as e:
         sys.stderr.write("error: could not resolve '%s': %s\n" %
                          (url, e))
         return
     result_data = response.read()
 
     # The result is expected to be a JSON object.
     try:
         return json.loads(result_data)