Merge branch 'clebergnu-python3_open_v2'

Signed-off-by: NAmador Pahim <apahim@redhat.com>

avocado/core/runner.py

@@ -66,7 +66,8 @@ def add_runner_failure(test_state, new_status, message):
     else:
         test_state["text_output"] = message + "\n"
     if test_log:
-        open(test_log, "a").write('\n' + message + '\n')
+        with open(test_log, "a") as log_file:
+            log_file.write('\n' + message + '\n')
     # Update the results
     if test_state.get("fail_reason"):
         test_state["fail_reason"] = "%s\n%s" % (test_state["fail_reason"],

avocado/core/sysinfo.py

@@ -349,19 +349,15 @@ class LogWatcher(Collectible):
             self.inode = current_inode
             self.size = current_size
 
-            in_messages = open(self.path)
-            out_messages = gzip.GzipFile(dstpath, "w")
-            try:
-                in_messages.seek(bytes_to_skip)
-                while True:
-                    # Read data in manageable chunks rather than all at once.
-                    in_data = in_messages.read(200000)
-                    if not in_data:
-                        break
-                    out_messages.write(in_data)
-            finally:
-                out_messages.close()
-                in_messages.close()
+            with open(self.path) as in_messages:
+                with gzip.GzipFile(dstpath, "w") as out_messages:
+                    in_messages.seek(bytes_to_skip)
+                    while True:
+                        # Read data in manageable chunks rather than all at once.
+                        in_data = in_messages.read(200000)
+                        if not in_data:
+                            break
+                        out_messages.write(in_data)
         except ValueError as e:
             log.info(e)
         except (IOError, OSError):

avocado/core/test.py

@@ -1144,11 +1144,12 @@ class SimpleTest(Test):
         except process.CmdError as details:
             self._log_detailed_cmd_info(details.result)
             raise exceptions.TestFail(details)
-        for line in open(self.logfile):
-            if self.re_avocado_log.match(line):
-                raise exceptions.TestWarn("Test passed but there were warnings"
-                                          " on stdout during execution. Check "
-                                          "the log for details.")
+        with open(self.logfile) as logfile:
+            for line in logfile:
+                if self.re_avocado_log.match(line):
+                    raise exceptions.TestWarn("Test passed but there were warnings"
+                                              " on stdout during execution. Check "
+                                              "the log for details.")
 
     def test(self):
         """

avocado/plugins/distro.py

@@ -245,7 +245,9 @@ def load_distro(path):
     :return: a dict with the distro definition data
     :rtype: dict
     """
-    return json.loads(bz2.decompress(open(path).read()))
+    with open(path, 'rb') as distro_file:
+        json_data = json.loads(bz2.decompress(distro_file.read()))
+    return json_data
 
 
 def load_from_tree(name, version, release, arch, package_type, path):

avocado/plugins/replay.py

@@ -103,27 +103,28 @@ class Replay(CLI):
         max_index = 0
         no_tests = 0
         _tests = {}
-        for line in open(path):
-            line = line.strip()
-            if line.startswith("#"):
-                continue
-            result = re_result.match(line)
-            if result:
-                if result.group(1) is None:
-                    res = result.group(5)
-                    if res is None:
-                        res = "PASS"
-                else:
-                    res = "ERROR"
-                index = int(result.group(2))
-                _tests[index] = {"status": res,
-                                 "test": result.group(3).rstrip()}
-                max_index = max(max_index, index)
-                continue
-            _no_tests = re_no_tests.match(line)
-            if _no_tests:
-                no_tests = int(_no_tests.group(1))
-                continue
+        with open(path) as tapfile:
+            for line in tapfile:
+                line = line.strip()
+                if line.startswith("#"):
+                    continue
+                result = re_result.match(line)
+                if result:
+                    if result.group(1) is None:
+                        res = result.group(5)
+                        if res is None:
+                            res = "PASS"
+                    else:
+                        res = "ERROR"
+                    index = int(result.group(2))
+                    _tests[index] = {"status": res,
+                                     "test": result.group(3).rstrip()}
+                    max_index = max(max_index, index)
+                    continue
+                _no_tests = re_no_tests.match(line)
+                if _no_tests:
+                    no_tests = int(_no_tests.group(1))
+                    continue
 
         if not (no_tests or max_index):
             return None

avocado/utils/asset.py

@@ -173,8 +173,8 @@ class Asset(object):
         if not os.path.isfile(self.hashfile):
             self._compute_hash()
 
-        with open(self.hashfile, 'r') as f:
-            for line in f.readlines():
+        with open(self.hashfile, 'r') as asset_file:
+            for line in asset_file:
                 # md5 is 32 chars big and sha512 is 128 chars big.
                 # others supported algorithms are between those.
                 pattern = '%s [a-f0-9]{32,128}' % self.algorithm

avocado/utils/cpu.py

@@ -44,10 +44,11 @@ def _get_cpu_info():
     :rtype: `list`
     """
     cpuinfo = []
-    for line in open('/proc/cpuinfo').readlines():
-        if line == '\n':
-            break
-        cpuinfo.append(line)
+    with open('/proc/cpuinfo') as proc_cpuinfo:
+        for line in proc_cpuinfo:
+            if line == '\n':
+                break
+            cpuinfo.append(line)
     return cpuinfo
 
 
@@ -60,8 +61,9 @@ def _get_cpu_status(cpu):
     :returns: `bool` True if online or False if not
     :rtype: 'bool'
     """
-    if '1' in open('/sys/devices/system/cpu/cpu%s/online' % cpu).read():
-        return True
+    with open('/sys/devices/system/cpu/cpu%s/online' % cpu) as online:
+        if '1' in online.read():
+            return True
     return False
 
 
@@ -134,9 +136,10 @@ def cpu_online_list():
     Reports a list of indexes of the online cpus
     """
     cpus = []
-    for line in open('/proc/cpuinfo', 'r'):
-        if line.startswith('processor'):
-            cpus.append(int(line.split()[2]))  # grab cpu number
+    with open('/proc/cpuinfo', 'r') as proc_cpuinfo:
+        for line in proc_cpuinfo:
+            if line.startswith('processor'):
+                cpus.append(int(line.split()[2]))  # grab cpu number
     return cpus
 
 

avocado/utils/crypto.py

@@ -56,21 +56,21 @@ def hash_file(filename, size=None, algorithm="md5"):
 
     if not size or size > fsize:
         size = fsize
-    f = open(filename, 'rb')
 
     try:
         hash_obj = hash_wrapper(algorithm=algorithm)
     except ValueError:
         logging.error("Unknown hash algorithm %s, returning None", algorithm)
 
-    while size > 0:
-        if chunksize > size:
-            chunksize = size
-        data = f.read(chunksize)
-        if len(data) == 0:
-            logging.debug("Nothing left to read but size=%d", size)
-            break
-        hash_obj.update(data)
-        size -= len(data)
-    f.close()
+    with open(filename, 'rb') as file_to_hash:
+        while size > 0:
+            if chunksize > size:
+                chunksize = size
+                data = file_to_hash.read(chunksize)
+                if len(data) == 0:
+                    logging.debug("Nothing left to read but size=%d", size)
+                    break
+                hash_obj.update(data)
+                size -= len(data)
+
     return hash_obj.hexdigest()

avocado/utils/distro.py

@@ -164,9 +164,10 @@ class Probe(object):
         """
         if self.check_name_for_file_contains():
             if os.path.exists(self.CHECK_FILE):
-                for line in open(self.CHECK_FILE).readlines():
-                    if self.CHECK_FILE_CONTAINS in line:
-                        return self.CHECK_FILE_DISTRO_NAME
+                with open(self.CHECK_FILE) as check_file:
+                    for line in check_file:
+                        if self.CHECK_FILE_CONTAINS in line:
+                            return self.CHECK_FILE_DISTRO_NAME
 
     def check_version(self):
         """
@@ -185,12 +186,12 @@ class Probe(object):
         Returns the match result for the version regex on the file content
         """
         if self.check_version():
-            if os.path.exists(self.CHECK_FILE):
-                version_file_content = open(self.CHECK_FILE).read()
-            else:
+            if not os.path.exists(self.CHECK_FILE):
                 return None
 
-            return self.CHECK_VERSION_REGEX.match(version_file_content)
+            with open(self.CHECK_FILE) as version_file:
+                version_file_content = version_file.read()
+                return self.CHECK_VERSION_REGEX.match(version_file_content)
 
     def version(self):
         """
@@ -366,10 +367,11 @@ class SUSEProbe(Probe):
         version_id_re = re.compile(r'VERSION_ID="([\d\.]*)"')
         version_id = None
 
-        for line in open(self.CHECK_FILE).readlines():
-            match = version_id_re.match(line)
-            if match:
-                version_id = match.group(1)
+        with open(self.check_file) as check_file:
+            for line in check_file:
+                match = version_id_re.match(line)
+                if match:
+                    version_id = match.group(1)
 
         if version_id:
             version_parts = version_id.split('.')

avocado/utils/download.py

@@ -67,11 +67,8 @@ def url_download(url, filename, data=None, timeout=300):
 
     src_file = url_open(url, data=data, timeout=timeout)
     try:
-        dest_file = open(filename, 'wb')
-        try:
+        with open(filename, 'wb') as dest_file:
             shutil.copyfileobj(src_file, dest_file)
-        finally:
-            dest_file.close()
     finally:
         src_file.close()
 
@@ -90,31 +87,29 @@ def url_download_interactive(url, output_file, title='', chunk_size=102400):
     :param chunk_size: amount of data to read at a time
     """
     output_dir = os.path.dirname(output_file)
-    output_file = open(output_file, 'w+b')
-    input_file = urlopen(url)
+    with open(output_file, 'w+b') as open_output_file:
+        input_file = urlopen(url)
 
-    try:
-        file_size = int(input_file.headers['Content-Length'])
-    except KeyError:
-        raise ValueError('Could not find file size in HTTP headers')
-
-    logging.info('Downloading %s, %s to %s', os.path.basename(url),
-                 output.display_data_size(file_size), output_dir)
-
-    progress_bar = output.ProgressBar(maximum=file_size, title=title)
-
-    # Download the file, while interactively updating the progress
-    progress_bar.draw()
-    while True:
-        data = input_file.read(chunk_size)
-        if data:
-            progress_bar.append_amount(len(data))
-            output_file.write(data)
-        else:
-            progress_bar.update_amount(file_size)
-            break
-
-    output_file.close()
+        try:
+            file_size = int(input_file.headers['Content-Length'])
+        except KeyError:
+            raise ValueError('Could not find file size in HTTP headers')
+
+        logging.info('Downloading %s, %s to %s', os.path.basename(url),
+                     output.display_data_size(file_size), output_dir)
+
+        progress_bar = output.ProgressBar(maximum=file_size, title=title)
+
+        # Download the file, while interactively updating the progress
+        progress_bar.draw()
+        while True:
+            data = input_file.read(chunk_size)
+            if data:
+                progress_bar.append_amount(len(data))
+                open_output_file.write(data)
+            else:
+                progress_bar.update_amount(file_size)
+                break
 
 
 def _get_file(src, dst, permissions=None):

avocado/utils/iso9660.py

@@ -91,9 +91,11 @@ def can_mount():
         logging.debug('Can not use mount: missing "mount" tool')
         return False
 
-    if 'iso9660' not in open('/proc/filesystems').read():
-        process.system("modprobe iso9660", ignore_status=True, sudo=True)
-        if 'iso9660' not in open('/proc/filesystems').read():
+    with open('/proc/filesystems') as proc_filesystems:
+        if 'iso9660' not in proc_filesystems.read():
+            process.system("modprobe iso9660", ignore_status=True, sudo=True)
+    with open('/proc/filesystems') as proc_filesystems:
+        if 'iso9660' not in proc_filesystems.read():
             logging.debug('Can not use mount: lack of iso9660 kernel support')
             return False
 
@@ -150,9 +152,8 @@ class BaseIso9660(object):
         :rtype: None
         """
         content = self.read(src)
-        output = open(dst, 'w+b')
-        output.write(content)
-        output.close()
+        with open(dst, 'w+b') as output:
+            output.write(content)
 
     def mnt_dir(self):
         """
@@ -283,10 +284,11 @@ class Iso9660IsoRead(MixInMntDirMount, BaseIso9660):
         self.temp_dir = tempfile.mkdtemp(prefix='avocado_' + __name__)
 
     def read(self, path):
-        temp_file = os.path.join(self.temp_dir, path)
-        cmd = 'iso-read -i %s -e %s -o %s' % (self.path, path, temp_file)
+        temp_path = os.path.join(self.temp_dir, path)
+        cmd = 'iso-read -i %s -e %s -o %s' % (self.path, path, temp_path)
         process.run(cmd)
-        return open(temp_file).read()
+        with open(temp_path) as temp_file:
+            return temp_file.read()
 
     def copy(self, src, dst):
         cmd = 'iso-read -i %s -e %s -o %s' % (self.path, src, dst)
@@ -329,7 +331,8 @@ class Iso9660Mount(BaseIso9660):
         :rtype: str
         """
         full_path = os.path.join(self.mnt_dir, path)
-        return open(full_path).read()
+        with open(full_path) as file_to_read:
+            return file_to_read.read()
 
     def copy(self, src, dst):
         """

avocado/utils/linux_modules.py

@@ -222,17 +222,18 @@ def check_kernel_config(config_name):
     kernel_version = platform.uname()[2]
 
     config_file = '/boot/config-' + kernel_version
-    for line in open(config_file, 'r'):
-        line = line.split('=')
-
-        if len(line) != 2:
-            continue
-
-        config = line[0].strip()
-        if config == config_name:
-            option = line[1].strip()
-            if option == "m":
-                return MODULE
-            else:
-                return BUILTIN
+    with open(config_file, 'r') as kernel_config:
+        for line in kernel_config:
+            line = line.split('=')
+
+            if len(line) != 2:
+                continue
+
+            config = line[0].strip()
+            if config == config_name:
+                option = line[1].strip()
+                if option == "m":
+                    return MODULE
+                else:
+                    return BUILTIN
     return NOT_SET

avocado/utils/memory.py

@@ -46,10 +46,10 @@ def _check_memory_state(block):
     :rtype: bool
     """
     def _is_online():
-        with open('/sys/devices/system/memory/memory%s/state' % block, 'r') as state_file:
-            if state_file.read() == 'online\n':
-                return True
-            return False
+        path = '/sys/devices/system/memory/memory%s/state' % block
+        if genio.read_file(path) == 'online\n':
+            return True
+        return False
 
     return wait.wait_for(_is_online, timeout=120, step=1) or False
 
@@ -75,8 +75,8 @@ def is_hot_pluggable(block):
     :return: True if hotpluggable, else False
     :rtype: 'bool'
     """
-    with open('/sys/devices/system/memory/memory%s/removable' % block, 'r') as file_obj:
-        return bool(int(file_obj.read()))
+    path = '/sys/devices/system/memory/memory%s/removable' % block
+    return bool(int(genio.read_file(path)))
 
 
 def hotplug(block):
@@ -136,11 +136,11 @@ def memtotal_sys():
     no_memblocks = 0
     for directory in os.listdir(sys_mempath):
         if directory.startswith('memory'):
-            if open(os.path.join(sys_mempath, directory, 'online'), "r").read().strip() == '1':
+            path = os.path.join(sys_mempath, directory, 'online')
+            if genio.read_file(path).strip() == '1':
                 no_memblocks += 1
-    block_size = int(open(os.path.join(sys_mempath,
-                                       'block_size_bytes'),
-                          "r").read().strip(), 16)
+    path = os.path.join(sys_mempath, 'block_size_bytes')
+    block_size = int(genio.read_file(path).strip(), 16)
     return (no_memblocks * block_size)/1024.0
 
 
@@ -266,10 +266,9 @@ def read_from_vmstat(key):
     :return: The value of the item
     :rtype: int
     """
-    vmstat = open("/proc/vmstat")
-    vmstat_info = vmstat.read()
-    vmstat.close()
-    return int(re.findall("%s\s+(\d+)" % key, vmstat_info)[0])
+    with open("/proc/vmstat") as vmstat:
+        vmstat_info = vmstat.read()
+        return int(re.findall("%s\s+(\d+)" % key, vmstat_info)[0])
 
 
 def read_from_smaps(pid, key):
@@ -283,15 +282,14 @@ def read_from_smaps(pid, key):
     :return: The value of the item in kb
     :rtype: int
     """
-    smaps = open("/proc/%s/smaps" % pid)
-    smaps_info = smaps.read()
-    smaps.close()
+    with open("/proc/%s/smaps" % pid) as smaps:
+        smaps_info = smaps.read()
 
-    memory_size = 0
-    for each_number in re.findall("%s:\s+(\d+)" % key, smaps_info):
-        memory_size += int(each_number)
+        memory_size = 0
+        for each_number in re.findall("%s:\s+(\d+)" % key, smaps_info):
+            memory_size += int(each_number)
 
-    return memory_size
+        return memory_size
 
 
 def read_from_numa_maps(pid, key):
@@ -306,16 +304,15 @@ def read_from_numa_maps(pid, key):
     :return: A dict using the address as the keys
     :rtype: dict
     """
-    numa_maps = open("/proc/%s/numa_maps" % pid)
-    numa_map_info = numa_maps.read()
-    numa_maps.close()
+    with open("/proc/%s/numa_maps" % pid) as numa_maps:
+        numa_map_info = numa_maps.read()
 
-    numa_maps_dict = {}
-    numa_pattern = r"(^[\dabcdfe]+)\s+.*%s[=:](\d+)" % key
-    for address, number in re.findall(numa_pattern, numa_map_info, re.M):
-        numa_maps_dict[address] = number
+        numa_maps_dict = {}
+        numa_pattern = r"(^[\dabcdfe]+)\s+.*%s[=:](\d+)" % key
+        for address, number in re.findall(numa_pattern, numa_map_info, re.M):
+            numa_maps_dict[address] = number
 
-    return numa_maps_dict
+        return numa_maps_dict
 
 
 def get_buddy_info(chunk_sizes, nodes="all", zones="all"):
@@ -346,46 +343,45 @@ def get_buddy_info(chunk_sizes, nodes="all", zones="all"):
     :return: A dict using the chunk_size as the keys
     :rtype: dict
     """
-    buddy_info = open("/proc/buddyinfo")
-    buddy_info_content = buddy_info.read()
-    buddy_info.close()
-
-    re_buddyinfo = "Node\s+"
-    if nodes == "all":
-        re_buddyinfo += "(\d+)"
-    else:
-        re_buddyinfo += "(%s)" % "|".join(nodes.split())
-
-    if not re.findall(re_buddyinfo, buddy_info_content):
-        logging.warn("Can not find Nodes %s" % nodes)
-        return None
-    re_buddyinfo += ".*?zone\s+"
-    if zones == "all":
-        re_buddyinfo += "(\w+)"
-    else:
-        re_buddyinfo += "(%s)" % "|".join(zones.split())
-    if not re.findall(re_buddyinfo, buddy_info_content):
-        logging.warn("Can not find zones %s" % zones)
-        return None
-    re_buddyinfo += "\s+([\s\d]+)"
-
-    buddy_list = re.findall(re_buddyinfo, buddy_info_content)
-
-    if re.findall("[<>=]", chunk_sizes) and buddy_list:
-        size_list = range(len(buddy_list[-1][-1].strip().split()))
-        chunk_sizes = [str(_) for _ in size_list if eval("%s %s" % (_,
-                                                                    chunk_sizes))]
-
-        chunk_sizes = ' '.join(chunk_sizes)
-
-    buddyinfo_dict = {}
-    for chunk_size in chunk_sizes.split():
-        buddyinfo_dict[chunk_size] = 0
-        for _, _, chunk_info in buddy_list:
-            chunk_info = chunk_info.strip().split()[int(chunk_size)]
-            buddyinfo_dict[chunk_size] += int(chunk_info)
-
-    return buddyinfo_dict
+    with open("/proc/buddyinfo") as buddy_info:
+        buddy_info_content = buddy_info.read()
+
+        re_buddyinfo = "Node\s+"
+        if nodes == "all":
+            re_buddyinfo += "(\d+)"
+        else:
+            re_buddyinfo += "(%s)" % "|".join(nodes.split())
+
+        if not re.findall(re_buddyinfo, buddy_info_content):
+            logging.warn("Can not find Nodes %s" % nodes)
+            return None
+        re_buddyinfo += ".*?zone\s+"
+        if zones == "all":
+            re_buddyinfo += "(\w+)"
+        else:
+            re_buddyinfo += "(%s)" % "|".join(zones.split())
+        if not re.findall(re_buddyinfo, buddy_info_content):
+            logging.warn("Can not find zones %s" % zones)
+            return None
+        re_buddyinfo += "\s+([\s\d]+)"
+
+        buddy_list = re.findall(re_buddyinfo, buddy_info_content)
+
+        if re.findall("[<>=]", chunk_sizes) and buddy_list:
+            size_list = range(len(buddy_list[-1][-1].strip().split()))
+            chunk_sizes = [str(_) for _ in size_list if eval("%s %s" % (_,
+                                                                        chunk_sizes))]
+
+            chunk_sizes = ' '.join(chunk_sizes)
+
+        buddyinfo_dict = {}
+        for chunk_size in chunk_sizes.split():
+            buddyinfo_dict[chunk_size] = 0
+            for _, _, chunk_info in buddy_list:
+                chunk_info = chunk_info.strip().split()[int(chunk_size)]
+                buddyinfo_dict[chunk_size] += int(chunk_info)
+
+        return buddyinfo_dict
 
 
 def set_thp_value(feature, value):

avocado/utils/partition.py

@@ -137,11 +137,12 @@ class Partition(object):
         """
         # Try to match this device/mountpoint
         if filename:
-            for line in open(filename):
-                parts = line.split()
-                if parts[0] == self.device or parts[1] == self.mountpoint:
-                    return parts[1]    # The mountpoint where it's mounted
-            return None
+            with open(filename) as open_file:
+                for line in open_file:
+                    parts = line.split()
+                    if parts[0] == self.device or parts[1] == self.mountpoint:
+                        return parts[1]    # The mountpoint where it's mounted
+                return None
 
         # no specific file given, look in /proc/mounts
         res = self.get_mountpoint(filename='/proc/mounts')

avocado/utils/path.py

@@ -111,9 +111,8 @@ class PathInspector(object):
     def get_first_line(self):
         first_line = ""
         if os.path.isfile(self.path):
-            checked_file = open(self.path, "r")
-            first_line = checked_file.readline()
-            checked_file.close()
+            with open(self.path, 'r') as open_file:
+                first_line = open_file.readline()
         return first_line
 
     def has_exec_permission(self):

avocado/utils/process.py

@@ -38,6 +38,7 @@ except ImportError:
 from . import gdb
 from . import runtime
 from . import path
+from . import genio
 
 log = logging.getLogger('avocado.test')
 stdout_log = logging.getLogger('avocado.test.stdout')
@@ -853,9 +854,8 @@ class GDBSubProcess(object):
         :rtype: str
         """
         os.mkfifo(path)
-        f = open(path, 'r')
-        c = f.read(1)
-        f.close()
+        with open(path, 'r') as fifo_file:
+            c = fifo_file.read(1)
         os.unlink(path)
         return c
 
@@ -865,10 +865,9 @@ class GDBSubProcess(object):
             binary_name = os.path.basename(self.binary)
             script_name = '%s.gdb.connect_commands' % binary_name
             path = os.path.join(current_test.outputdir, script_name)
-            cmds = open(path, 'w')
-            cmds.write('file %s\n' % os.path.abspath(self.binary))
-            cmds.write('target extended-remote :%s\n' % self.gdb_server.port)
-            cmds.close()
+            with open(path, 'w') as cmds_file:
+                cmds_file('file %s\n' % os.path.abspath(self.binary))
+                cmds_file('target extended-remote :%s\n' % self.gdb_server.port)
             return path
 
     def generate_gdb_connect_sh(self):
@@ -886,11 +885,10 @@ class GDBSubProcess(object):
             script_name = '%s.gdb.sh' % binary_name
             script_path = os.path.join(current_test.outputdir, script_name)
 
-            script = open(script_path, 'w')
-            script.write("#!/bin/sh\n")
-            script.write("%s -x %s\n" % (gdb.GDB_PATH, cmds))
-            script.write("echo -n 'C' > %s\n" % fifo_path)
-            script.close()
+            with open(script_path, 'w') as script_file:
+                script_file.write("#!/bin/sh\n")
+                script_file.write("%s -x %s\n" % (gdb.GDB_PATH, cmds))
+                script_file.write("echo -n 'C' > %s\n" % fifo_path)
             os.chmod(script_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
             return (script_path, fifo_path)
 
@@ -1043,8 +1041,7 @@ class GDBSubProcess(object):
             gdb.GDB_PRERUN_COMMANDS.get('', None))
 
         if prerun_commands_path is not None:
-            prerun_commands = open(prerun_commands_path).readlines()
-            for command in prerun_commands:
+            for command in genio.read_all_lines(prerun_commands_path):
                 self.gdb.cmd(command)
 
     def run(self, timeout=None):
@@ -1073,10 +1070,10 @@ class GDBSubProcess(object):
                 if current_test is not None:
                     if os.path.exists(self.gdb_server.stdout_path):
                         shutil.copy(self.gdb_server.stdout_path, stdout_path)
-                        self.result.stdout = open(stdout_path, 'r').read()
+                        self.result.stdout = genio.read_file(stdout_path)
                     if os.path.exists(self.gdb_server.stderr_path):
                         shutil.copy(self.gdb_server.stderr_path, stderr_path)
-                        self.result.stderr = open(stderr_path, 'r').read()
+                        self.result.stderr = genio.read_file(stderr_path)
 
                 self.gdb_server.exit()
                 return self.result

docs/source/conf.py

@@ -13,6 +13,7 @@ sys.path.insert(0, root_path)
 
 from avocado.utils import path
 from avocado.utils import process
+from avocado.utils import genio
 
 # Flag that tells if the docs are being built on readthedocs.org
 ON_RTD = os.environ.get('READTHEDOCS', None) == 'True'
@@ -40,7 +41,7 @@ API_SECTIONS = {"Test APIs": (None,
                               ("modules.rst", )),
 
                 "Utilities APIs": ("utils",
-                                   open("api_utils_heading", "r").read(),
+                                   genio.read_file("api_utils_heading"),
                                    "utils",
                                    ("core", "plugins"),
                                    ("avocado.rst", "modules.rst")),
@@ -93,14 +94,14 @@ for (section, params) in API_SECTIONS.iteritems():
             if not details.errno == errno.EEXIST:
                 raise
     else:
-        main_rst_content = open(main_rst).readlines()
+        with open(main_rst) as main_rst_file:
+            main_rst_content = main_rst_file.readlines()
 
     new_main_rst_content = [section, "=" * len(section), "",
                             params[1], ""]
-    new_main_rst = open(main_rst, "w")
-    new_main_rst.write("\n".join(new_main_rst_content))
-    new_main_rst.write("".join(main_rst_content[2:]))
-    new_main_rst.close()
+    with open(main_rst, "w") as new_main_rst:
+        new_main_rst.write("\n".join(new_main_rst_content))
+        new_main_rst.write("".join(main_rst_content[2:]))
 
 # Generate optional-plugins
 optional_plugins_path = os.path.join(root_path, "optional_plugins")
@@ -150,7 +151,7 @@ project = u'Avocado'
 copyright = u'2014-2015, Red Hat'
 
 version_file = os.path.join(root_path, 'VERSION')
-VERSION = open(version_file, 'r').read().strip()
+VERSION = genio.read_file(version_file).strip()
 version = VERSION
 release = VERSION
 

examples/tests/gdbtest.py

@@ -7,6 +7,7 @@ from six.moves import xrange as range
 from avocado import Test
 from avocado import main
 from avocado.utils import gdb
+from avocado.utils import genio
 from avocado.utils import process
 
 
@@ -358,7 +359,7 @@ class GdbTest(Test):
         s.exit()
         self.assertTrue(os.path.exists(s.stderr_path))
 
-        stderr_lines = open(s.stderr_path, 'r').readlines()
+        stderr_lines = genio.read_all_lines(s.stderr_path)
         listening_line = "Listening on port %s\n" % s.port
         self.assertIn(listening_line, stderr_lines)
 
@@ -374,7 +375,7 @@ class GdbTest(Test):
         self.assertTrue(os.path.exists(s.stdout_path))
         self.assertTrue(os.path.exists(s.stderr_path))
 
-        stdout_lines = open(s.stdout_path, 'r').readlines()
+        stdout_lines = genio.read_all_lines(s.stdout_path)
         self.assertIn("return 99\n", stdout_lines)
 
     def test_interactive_stdout(self):

examples/tests/gendata.py

@@ -4,6 +4,7 @@ import os
 
 from avocado import Test
 from avocado import main
+from avocado.utils import genio
 
 
 class GenDataTest(Test):
@@ -23,8 +24,7 @@ class GenDataTest(Test):
         dmesg_path = os.path.join(self.job.logdir, "sysinfo", "pre", "dmesg_-c")
         self.log.info("dmesg_path: %s", dmesg_path)
         if os.path.exists(dmesg_path):
-            dmesg = open(dmesg_path)
-            text = dmesg.readlines()[0:50]
+            text = genio.read_all_lines(dmesg_path)[0:50]
 
         bsod = Image.new("RGB", (640, 480), "blue")
         draw = ImageDraw.Draw(bsod)
@@ -39,7 +39,8 @@ class GenDataTest(Test):
         output_path = os.path.join(self.outputdir, "test.json")
         output = {"basedir": self.basedir,
                   "outputdir": self.outputdir}
-        json.dump(output, open(output_path, "w"))
+        with open(output_path, "w") as output_file:
+            json.dump(output, output_file)
 
 
 if __name__ == "__main__":

examples/tests/test_env.py

@@ -2,6 +2,7 @@ import os
 import sys
 
 from avocado import Test
+from avocado.utils import genio
 
 
 class Env(Test):
@@ -15,7 +16,7 @@ class Env(Test):
 
         def get_proc_content(rel_path):
             try:
-                return open(os.path.join(p_dir, rel_path)).read().strip()
+                return genio.read_file(os.path.join(p_dir, rel_path)).strip()
             except:
                 return "<NOT AVAILABLE>"
 

examples/tests/whiteboard.py

@@ -25,9 +25,9 @@ class WhiteBoard(Test):
         if data_file:
             self.log.info('Writing data to whiteboard from file: %s',
                           data_file)
-            whiteboard_file = open(data_file, 'r')
-            size = int(data_size)
-            data = whiteboard_file.read(size)
+            with open(data_file, 'r') as whiteboard_file:
+                size = int(data_size)
+                data = whiteboard_file.read(size)
         else:
             offset = int(data_size) - 1
             data = self.params.get('whiteboard_data_text',

selftests/functional/test_basic.py

@@ -23,6 +23,7 @@ from six.moves import xrange as range
 
 from avocado.core import exit_codes
 from avocado.utils import astring
+from avocado.utils import genio
 from avocado.utils import process
 from avocado.utils import script
 from avocado.utils import path as utils_path
@@ -526,7 +527,7 @@ class RunnerOperationTest(unittest.TestCase):
                " foo:bar:b foo:baz:c bar:bar:bar --dry-run" % AVOCADO)
         result = json.loads(process.run(cmd).stdout)
         debuglog = result['debuglog']
-        log = open(debuglog, 'r').read()
+        log = genio.read_file(debuglog)
         # Remove the result dir
         shutil.rmtree(os.path.dirname(os.path.dirname(debuglog)))
         self.assertIn(tempfile.gettempdir(), debuglog)   # Use tmp dir, not default location
@@ -839,9 +840,10 @@ class RunnerSimpleTest(unittest.TestCase):
                          "1.")
 
         sleep_dir = astring.string_to_safe_path("1-60")
-        debug_log = os.path.join(self.tmpdir, "latest", "test-results",
-                                 sleep_dir, "debug.log")
-        debug_log = open(debug_log).read()
+        debug_log_path = os.path.join(self.tmpdir, "latest", "test-results",
+                                      sleep_dir, "debug.log")
+
+        debug_log = genio.read_file(debug_log_path)
         self.assertIn("Runner error occurred: Timeout reached", debug_log,
                       "Runner error occurred: Timeout reached message not "
                       "in the test's debug.log:\n%s" % debug_log)

selftests/functional/test_job_timeout.py

@@ -6,6 +6,7 @@ import xml.dom.minidom
 import unittest
 
 from avocado.core import exit_codes
+from avocado.utils import genio
 from avocado.utils import process
 from avocado.utils import script
 
@@ -98,8 +99,8 @@ class JobTimeOutTest(unittest.TestCase):
 
     def _check_timeout_msg(self, idx):
         res_dir = os.path.join(self.tmpdir, "latest", "test-results")
-        debug_log = glob.glob(os.path.join(res_dir, "%s-*" % idx, "debug.log"))
-        debug_log = open(debug_log[0]).read()
+        debug_log_paths = glob.glob(os.path.join(res_dir, "%s-*" % idx, "debug.log"))
+        debug_log = genio.read_file(debug_log_paths[0])
         self.assertIn("Runner error occurred: Timeout reached", debug_log,
                       "Runner error occurred: Timeout reached message not "
                       "in the %sst test's debug.log:\n%s"

selftests/functional/test_output.py

@@ -10,6 +10,7 @@ import pkg_resources
 
 from avocado.core import exit_codes
 from avocado.core.output import TermSupport
+from avocado.utils import genio
 from avocado.utils import process
 from avocado.utils import script
 from avocado.utils import path as utils_path
@@ -165,15 +166,18 @@ class OutputTest(unittest.TestCase):
         def _check_output(path, exps, name):
             i = 0
             end = len(exps)
-            for line in open(path):
-                if exps[i] in line:
-                    i += 1
-                    if i == end:
-                        break
-            self.assertEqual(i, end, "Failed to find %sth message from\n%s\n"
-                             "\nin the %s. Either it's missing or in wrong "
-                             "order.\n%s" % (i, "\n".join(exps), name,
-                                             open(path).read()))
+            with open(path) as output_file:
+                output_file_content = output_file.read()
+                output_file.seek(0)
+                for line in output_file:
+                    if exps[i] in line:
+                        i += 1
+                        if i == end:
+                            break
+                self.assertEqual(i, end, "Failed to find %sth message from\n%s\n"
+                                 "\nin the %s. Either it's missing or in wrong "
+                                 "order.\n%s" % (i, "\n".join(exps), name,
+                                                 output_file_content))
         test = script.Script(os.path.join(self.tmpdir, "output_test.py"),
                              OUTPUT_TEST_CONTENT)
         test.save()
@@ -189,10 +193,12 @@ class OutputTest(unittest.TestCase):
                 "[stderr] test_stderr", "[stdout] test_process"]
         _check_output(joblog, exps, "job.log")
         testdir = res["tests"][0]["logdir"]
-        self.assertEqual("test_print\ntest_stdout\ntest_process__test_stdout__",
-                         open(os.path.join(testdir, "stdout")).read())
-        self.assertEqual("test_stderr\n__test_stderr__",
-                         open(os.path.join(testdir, "stderr")).read())
+        with open(os.path.join(testdir, "stdout")) as stdout_file:
+            self.assertEqual("test_print\ntest_stdout\ntest_process__test_stdout__",
+                             stdout_file.read())
+        with open(os.path.join(testdir, "stderr")) as stderr_file:
+            self.assertEqual("test_stderr\n__test_stderr__",
+                             stderr_file.read())
 
         # Now run the same test, but with combined output
         # combined output can not keep track of sys.stdout and sys.stdout
@@ -205,8 +211,9 @@ class OutputTest(unittest.TestCase):
                              "--json - -- %s" % (AVOCADO, self.tmpdir, test))
         res = json.loads(result.stdout)
         testdir = res["tests"][0]["logdir"]
-        self.assertEqual("test_process__test_stderr____test_stdout__",
-                         open(os.path.join(testdir, "output")).read())
+        with open(os.path.join(testdir, "output")) as output_file:
+            self.assertEqual("test_process__test_stderr____test_stdout__",
+                             output_file.read())
 
     def test_check_record_no_module_default(self):
         """
@@ -276,20 +283,21 @@ class OutputPluginTest(unittest.TestCase):
 
     def check_output_files(self, debug_log):
         base_dir = os.path.dirname(debug_log)
-        json_output = os.path.join(base_dir, 'results.json')
-        self.assertTrue(os.path.isfile(json_output))
-        with open(json_output, 'r') as fp:
+        json_output_path = os.path.join(base_dir, 'results.json')
+        self.assertTrue(os.path.isfile(json_output_path))
+        with open(json_output_path, 'r') as fp:
             json.load(fp)
-        xunit_output = os.path.join(base_dir, 'results.xml')
-        self.assertTrue(os.path.isfile(json_output))
+        xunit_output_path = os.path.join(base_dir, 'results.xml')
+        self.assertTrue(os.path.isfile(json_output_path))
         try:
-            minidom.parse(xunit_output)
+            minidom.parse(xunit_output_path)
         except Exception as details:
+            xunit_output_content = genio.read_file(xunit_output_path)
             raise AssertionError("Unable to parse xunit output: %s\n\n%s"
-                                 % (details, open(xunit_output).read()))
+                                 % (details, xunit_output_content))
         tap_output = os.path.join(base_dir, "results.tap")
         self.assertTrue(os.path.isfile(tap_output))
-        tap = open(tap_output).read()
+        tap = genio.read_file(tap_output)
         self.assertIn("..", tap)
         self.assertIn("\n# debug.log of ", tap)
 

selftests/functional/test_skiptests.py

@@ -5,6 +5,7 @@ import tempfile
 import unittest
 
 from avocado.core import exit_codes
+from avocado.utils import genio
 from avocado.utils import process
 from avocado.utils import script
 
@@ -119,9 +120,10 @@ class TestSkipDecorators(unittest.TestCase):
 
         self.assertEqual(result.exit_status, exit_codes.AVOCADO_ALL_OK)
         self.assertEqual(json_results['skip'], 3)
-        self.assertFalse('setup executed' in open(debuglog, 'r').read())
-        self.assertFalse('test executed' in open(debuglog, 'r').read())
-        self.assertFalse('teardown executed' in open(debuglog, 'r').read())
+        debuglog_contents = genio.read_file(debuglog)
+        self.assertFalse('setup executed' in debuglog_contents)
+        self.assertFalse('test executed' in debuglog_contents)
+        self.assertFalse('teardown executed' in debuglog_contents)
 
     def test_skip_setup(self):
         os.chdir(basedir)

selftests/functional/test_statuses.py

@@ -4,6 +4,7 @@ import shutil
 import tempfile
 import unittest
 
+from avocado.utils import genio
 from avocado.utils import process
 
 
@@ -183,7 +184,7 @@ class TestStatuses(unittest.TestCase):
         self.assertEqual(expected[0], test['status'],
                          "Status error: '%s' != '%s' (%s)" %
                          (expected[0], test['status'], variant))
-        debug_log = open(test['logfile'], 'r').read()
+        debug_log = genio.read_file(test['logfile'])
         for msg in expected[1]:
             self.assertIn(msg, debug_log,
                           "Message '%s' should be in the log (%s)."

selftests/unit/test_job.py

@@ -110,8 +110,9 @@ class JobTest(unittest.TestCase):
             myjob.run_tests()
         finally:
             myjob.post_tests()
-        self.assertEqual(myjob.unique_id[::-1],
-                         open(os.path.join(myjob.logdir, "reversed_id")).read())
+        with open(os.path.join(myjob.logdir, "reversed_id")) as reverse_id_file:
+            self.assertEqual(myjob.unique_id[::-1],
+                             reverse_id_file.read())
 
     def test_job_run(self):
         class JobFilterLog(job.Job):
@@ -135,8 +136,9 @@ class JobTest(unittest.TestCase):
         self.assertEqual(myjob.run(),
                          exit_codes.AVOCADO_ALL_OK)
         self.assertLessEqual(len(myjob.test_suite), 1)
-        self.assertEqual(myjob.unique_id[::-1],
-                         open(os.path.join(myjob.logdir, "reversed_id")).read())
+        with open(os.path.join(myjob.logdir, "reversed_id")) as reverse_id_file:
+            self.assertEqual(myjob.unique_id[::-1],
+                             reverse_id_file.read())
 
     def test_job_run_account_time(self):
         args = argparse.Namespace(base_logdir=self.tmpdir)

selftests/unit/test_utils_partition.py

@@ -50,10 +50,14 @@ class TestPartition(unittest.TestCase):
         self.assertEqual(None, self.disk.get_mountpoint())
         self.disk.mkfs()
         self.disk.mount()
-        self.assertIn(self.mountpoint, open("/proc/mounts").read())
-        self.assertEqual(self.mountpoint, self.disk.get_mountpoint())
-        self.disk.unmount()
-        self.assertNotIn(self.mountpoint, open("/proc/mounts").read())
+        with open("/proc/mounts") as proc_mounts_file:
+            proc_mounts = proc_mounts_file.read()
+            self.assertIn(self.mountpoint, proc_mounts)
+            self.assertEqual(self.mountpoint, self.disk.get_mountpoint())
+            self.disk.unmount()
+        with open("/proc/mounts") as proc_mounts_file:
+            proc_mounts = proc_mounts_file.read()
+            self.assertNotIn(self.mountpoint, proc_mounts)
 
     @unittest.skipIf(not process.can_sudo('kill -l'),
                      "requires running kill as a privileged user")
@@ -61,37 +65,51 @@ class TestPartition(unittest.TestCase):
         """ Test force-unmount feature """
         self.disk.mkfs()
         self.disk.mount()
-        self.assertIn(self.mountpoint, open("/proc/mounts").read())
-        proc = process.SubProcess("cd %s; while :; do echo a > a; rm a; done"
-                                  % self.mountpoint, shell=True)
-        proc.start()
-        self.assertTrue(self.disk.unmount())
-        self.assertEqual(proc.poll(), -9)   # Process should be killed -9
-        self.assertNotIn(self.mountpoint, open("/proc/mounts").read())
+        with open("/proc/mounts") as proc_mounts_file:
+            proc_mounts = proc_mounts_file.read()
+            self.assertIn(self.mountpoint, proc_mounts)
+            proc = process.SubProcess("cd %s; while :; do echo a > a; rm a; done"
+                                      % self.mountpoint, shell=True)
+            proc.start()
+            self.assertTrue(self.disk.unmount())
+            self.assertEqual(proc.poll(), -9)   # Process should be killed -9
+        with open("/proc/mounts") as proc_mounts_file:
+            proc_mounts = proc_mounts_file.read()
+            self.assertNotIn(self.mountpoint, proc_mounts)
 
     def test_double_mount(self):
         """ Check the attempt for second mount fails """
         self.disk.mkfs()
         self.disk.mount()
-        self.assertIn(self.mountpoint, open("/proc/mounts").read())
-        self.assertRaises(partition.PartitionError, self.disk.mount)
-        self.assertIn(self.mountpoint, open("/proc/mounts").read())
+        with open("/proc/mounts") as proc_mounts_file:
+            proc_mounts = proc_mounts_file.read()
+            self.assertIn(self.mountpoint, proc_mounts)
+            self.assertRaises(partition.PartitionError, self.disk.mount)
+            self.assertIn(self.mountpoint, proc_mounts)
 
     def test_double_umount(self):
         """ Check double unmount works well """
         self.disk.mkfs()
         self.disk.mount()
-        self.assertIn(self.mountpoint, open("/proc/mounts").read())
+        with open("/proc/mounts") as proc_mounts_file:
+            proc_mounts = proc_mounts_file.read()
+            self.assertIn(self.mountpoint, proc_mounts)
         self.disk.unmount()
-        self.assertNotIn(self.mountpoint, open("/proc/mounts").read())
+        with open("/proc/mounts") as proc_mounts_file:
+            proc_mounts = proc_mounts_file.read()
+            self.assertNotIn(self.mountpoint, proc_mounts)
         self.disk.unmount()
-        self.assertNotIn(self.mountpoint, open("/proc/mounts").read())
+        with open("/proc/mounts") as proc_mounts_file:
+            proc_mounts = proc_mounts_file.read()
+            self.assertNotIn(self.mountpoint, proc_mounts)
 
     def test_format_mounted(self):
         """ Check format on mounted device fails """
         self.disk.mkfs()
         self.disk.mount()
-        self.assertIn(self.mountpoint, open("/proc/mounts").read())
+        with open("/proc/mounts") as proc_mounts_file:
+            proc_mounts = proc_mounts_file.read()
+            self.assertIn(self.mountpoint, proc_mounts)
         self.assertRaises(partition.PartitionError, self.disk.mkfs)
 
     def tearDown(self):

setup.py

@@ -21,7 +21,8 @@ import sys
 from setuptools import setup, find_packages
 
 BASE_PATH = os.path.dirname(__file__)
-VERSION = open(os.path.join(BASE_PATH, 'VERSION'), 'r').read().strip()
+with open(os.path.join(BASE_PATH, 'VERSION'), 'r') as version_file:
+    VERSION = version_file.read().strip()
 VIRTUAL_ENV = (hasattr(sys, 'real_prefix') or 'VIRTUAL_ENV' in os.environ)