use context manager for stdin files and use _put_file_shell

requires https://gerrit.opnfv.org/gerrit/#/c/25183/

use new ssh method _put_file_shell to upload files.
We have to use _put_file_shell because we rely on ~/ path
expansions.  Eventually we should move to remote absolute
paths so we can use sftp upload.

For ssh.execute() replace open() with context manager

context managers were invented partly to control
freeing resources.  Opening files without closing
them will leak file descriptors.

The old standard method for closing files:

f = open('data.txt')
try:
    data = f.read()
finally:
    f.close()

was replaced with a context manager

with open('data.txt') as f:
    data = f.read()

Reference:  Raymond Hettinger's Pycon 2013 presentation:
https://speakerdeck.com/pyconslides/transforming-code-into-beautiful-idiomatic-python-by-raymond-hettinger-1

Video: https://youtu.be/OSGv2VnC0go?t=2522

Always use context managers for files

Update:
   rebased now that _put_file_shell was merged

Change-Id: Iabfc0e43aa3b7766d7c658115e13d21c31efb2a9
Signed-off-by: Ross Brattain <ross.b.brattain@intel.com>

8 files changed, 77 insertions, 58 deletions

diff --git a/yardstick/benchmark/scenarios/availability/attacker/attacker_baremetal.py b/yardstick/benchmark/scenarios/availability/attacker/attacker_baremetal.py
index 3b1f8ef76..e88fed636 100644
--- a/yardstick/benchmark/scenarios/availability/attacker/attacker_baremetal.py
+++ b/yardstick/benchmark/scenarios/availability/attacker/attacker_baremetal.py
@@ -61,9 +61,10 @@ class BaremetalAttacker(BaseAttacker):
             self.setup_done = True
 
     def check(self):
-        exit_status, stdout, stderr = self.connection.execute(
-            "/bin/sh -s {0} -W 10".format(self.host_ip),
-            stdin=open(self.check_script, "r"))
+        with open(self.check_script, "r") as stdin_file:
+            exit_status, stdout, stderr = self.connection.execute(
+                "/bin/sh -s {0} -W 10".format(self.host_ip),
+                stdin=stdin_file)
 
         LOG.debug("check ret: %s out:%s err:%s",
                   exit_status, stdout, stderr)
@@ -98,10 +99,11 @@ class BaremetalAttacker(BaseAttacker):
             LOG.debug("ssh jump host success!")
 
         if self.jump_connection is not None:
-            exit_status, stdout, stderr = self.jump_connection.execute(
-                "/bin/bash -s {0} {1} {2} {3}".format(
-                    self.ipmi_ip, self.ipmi_user, self.ipmi_pwd, "on"),
-                stdin=open(self.recovery_script, "r"))
+            with open(self.recovery_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.jump_connection.execute(
+                    "/bin/bash -s {0} {1} {2} {3}".format(
+                        self.ipmi_ip, self.ipmi_user, self.ipmi_pwd, "on"),
+                    stdin=stdin_file)
         else:
             exit_status, stdout = _execute_shell_command(
                 "/bin/bash -s {0} {1} {2} {3}".format(
diff --git a/yardstick/benchmark/scenarios/availability/attacker/attacker_general.py b/yardstick/benchmark/scenarios/availability/attacker/attacker_general.py
index a452c37ac..595067a95 100644
--- a/yardstick/benchmark/scenarios/availability/attacker/attacker_general.py
+++ b/yardstick/benchmark/scenarios/availability/attacker/attacker_general.py
@@ -65,13 +65,15 @@ class GeneralAttacker(BaseAttacker):
 
         if "action_parameter" in self._config:
             LOG.debug("the shell command is: {0}".format(self.action_param))
-            exit_status, stdout, stderr = self.connection.execute(
-                self.action_param,
-                stdin=open(self.inject_script, "r"))
+            with open(self.inject_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.connection.execute(
+                    self.action_param,
+                    stdin=stdin_file)
         else:
-            exit_status, stdout, stderr = self.connection.execute(
-                "/bin/bash -s ",
-                stdin=open(self.inject_script, "r"))
+            with open(self.inject_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.connection.execute(
+                    "/bin/bash -s ",
+                    stdin=stdin_file)
 
         LOG.debug("the inject_fault's exit status is: {0}".format(exit_status))
         if exit_status == 0:
@@ -85,10 +87,12 @@ class GeneralAttacker(BaseAttacker):
     def recover(self):
         if "rollback_parameter" in self._config:
             LOG.debug("the shell command is: {0}".format(self.rollback_param))
-            exit_status, stdout, stderr = self.connection.execute(
-                self.rollback_param,
-                stdin=open(self.recovery_script, "r"))
+            with open(self.recovery_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.connection.execute(
+                    self.rollback_param,
+                    stdin=stdin_file)
         else:
-            exit_status, stdout, stderr = self.connection.execute(
-                "/bin/bash -s ",
-                stdin=open(self.recovery_script, "r"))
+            with open(self.recovery_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.connection.execute(
+                    "/bin/bash -s ",
+                    stdin=stdin_file)
diff --git a/yardstick/benchmark/scenarios/availability/attacker/attacker_process.py b/yardstick/benchmark/scenarios/availability/attacker/attacker_process.py
index 2ccc231da..1d190a160 100644
--- a/yardstick/benchmark/scenarios/availability/attacker/attacker_process.py
+++ b/yardstick/benchmark/scenarios/availability/attacker/attacker_process.py
@@ -45,9 +45,10 @@ class ProcessAttacker(BaseAttacker):
             self.setup_done = True
 
     def check(self):
-        exit_status, stdout, stderr = self.connection.execute(
-            "/bin/sh -s {0}".format(self.service_name),
-            stdin=open(self.check_script, "r"))
+        with open(self.check_script, "r") as stdin_file:
+            exit_status, stdout, stderr = self.connection.execute(
+                "/bin/sh -s {0}".format(self.service_name),
+                stdin=stdin_file)
 
         if stdout and "running" in stdout:
             LOG.info("check the envrioment success!")
@@ -59,11 +60,13 @@ class ProcessAttacker(BaseAttacker):
         return False
 
     def inject_fault(self):
-        exit_status, stdout, stderr = self.connection.execute(
-            "/bin/sh -s {0}".format(self.service_name),
-            stdin=open(self.inject_script, "r"))
+        with open(self.inject_script, "r") as stdin_file:
+            exit_status, stdout, stderr = self.connection.execute(
+                "/bin/sh -s {0}".format(self.service_name),
+                stdin=stdin_file)
 
     def recover(self):
-        exit_status, stdout, stderr = self.connection.execute(
-            "/bin/sh -s {0} ".format(self.service_name),
-            stdin=open(self.recovery_script, "r"))
+        with open(self.recovery_script, "r") as stdin_file:
+            exit_status, stdout, stderr = self.connection.execute(
+                "/bin/sh -s {0} ".format(self.service_name),
+                stdin=stdin_file)
diff --git a/yardstick/benchmark/scenarios/availability/monitor/monitor_command.py b/yardstick/benchmark/scenarios/availability/monitor/monitor_command.py
index 366d16e73..cd33e6188 100644
--- a/yardstick/benchmark/scenarios/availability/monitor/monitor_command.py
+++ b/yardstick/benchmark/scenarios/availability/monitor/monitor_command.py
@@ -58,9 +58,10 @@ class MonitorOpenstackCmd(basemonitor.BaseMonitor):
     def monitor_func(self):
         exit_status = 0
         if self.connection:
-            exit_status, stdout, stderr = self.connection.execute(
-                "/bin/bash -s '{0}'".format(self.cmd),
-                stdin=open(self.check_script, "r"))
+            with open(self.check_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.connection.execute(
+                    "/bin/bash -s '{0}'".format(self.cmd),
+                    stdin=stdin_file)
 
             LOG.debug("the ret stats: %s stdout: %s stderr: %s",
                       exit_status, stdout, stderr)
diff --git a/yardstick/benchmark/scenarios/availability/monitor/monitor_general.py b/yardstick/benchmark/scenarios/availability/monitor/monitor_general.py
index 359cde671..461a2ded5 100644
--- a/yardstick/benchmark/scenarios/availability/monitor/monitor_general.py
+++ b/yardstick/benchmark/scenarios/availability/monitor/monitor_general.py
@@ -48,13 +48,15 @@ class GeneralMonitor(basemonitor.BaseMonitor):
 
     def monitor_func(self):
         if "parameter" in self._config:
-            exit_status, stdout, stderr = self.connection.execute(
-                self.cmd_param,
-                stdin=open(self.monitor_script, "r"))
+            with open(self.monitor_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.connection.execute(
+                    self.cmd_param,
+                    stdin=stdin_file)
         else:
-            exit_status, stdout, stderr = self.connection.execute(
-                "/bin/bash -s ",
-                stdin=open(self.monitor_script, "r"))
+            with open(self.monitor_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.connection.execute(
+                    "/bin/bash -s ",
+                    stdin=stdin_file)
 
         if exit_status:
             return False
diff --git a/yardstick/benchmark/scenarios/availability/monitor/monitor_process.py b/yardstick/benchmark/scenarios/availability/monitor/monitor_process.py
index a88b8d42e..5f492ad69 100644
--- a/yardstick/benchmark/scenarios/availability/monitor/monitor_process.py
+++ b/yardstick/benchmark/scenarios/availability/monitor/monitor_process.py
@@ -35,9 +35,10 @@ class MonitorProcess(basemonitor.BaseMonitor):
         self.process_name = self._config["process_name"]
 
     def monitor_func(self):
-        exit_status, stdout, stderr = self.connection.execute(
-            "/bin/sh -s {0}".format(self.process_name),
-            stdin=open(self.check_script, "r"))
+        with open(self.check_script, "r") as stdin_file:
+            exit_status, stdout, stderr = self.connection.execute(
+                "/bin/sh -s {0}".format(self.process_name),
+                stdin=stdin_file)
         if not stdout or int(stdout) <= 0:
             LOG.info("the process (%s) is not running!", self.process_name)
             return False
diff --git a/yardstick/benchmark/scenarios/availability/operation/operation_general.py b/yardstick/benchmark/scenarios/availability/operation/operation_general.py
index b3a20c344..c82df836d 100644
--- a/yardstick/benchmark/scenarios/availability/operation/operation_general.py
+++ b/yardstick/benchmark/scenarios/availability/operation/operation_general.py
@@ -55,13 +55,15 @@ class GeneralOperaion(BaseOperation):
 
     def run(self):
         if "action_parameter" in self._config:
-            exit_status, stdout, stderr = self.connection.execute(
-                self.action_param,
-                stdin=open(self.action_script, "r"))
+            with open(self.action_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.connection.execute(
+                    self.action_param,
+                    stdin=stdin_file)
         else:
-            exit_status, stdout, stderr = self.connection.execute(
-                "/bin/sh -s ",
-                stdin=open(self.action_script, "r"))
+            with open(self.action_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.connection.execute(
+                    "/bin/sh -s ",
+                    stdin=stdin_file)
 
         if exit_status == 0:
             LOG.debug("success,the operation's output is: {0}".format(stdout))
@@ -72,10 +74,12 @@ class GeneralOperaion(BaseOperation):
 
     def rollback(self):
         if "rollback_parameter" in self._config:
-            exit_status, stdout, stderr = self.connection.execute(
-                self.rollback_param,
-                stdin=open(self.rollback_script, "r"))
+            with open(self.rollback_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.connection.execute(
+                    self.rollback_param,
+                    stdin=stdin_file)
         else:
-            exit_status, stdout, stderr = self.connection.execute(
-                "/bin/sh -s ",
-                stdin=open(self.rollback_script, "r"))
+            with open(self.rollback_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.connection.execute(
+                    "/bin/sh -s ",
+                    stdin=stdin_file)
diff --git a/yardstick/benchmark/scenarios/availability/result_checker/result_checker_general.py b/yardstick/benchmark/scenarios/availability/result_checker/result_checker_general.py
index 8c9d16026..275aff076 100644
--- a/yardstick/benchmark/scenarios/availability/result_checker/result_checker_general.py
+++ b/yardstick/benchmark/scenarios/availability/result_checker/result_checker_general.py
@@ -53,17 +53,19 @@ class GeneralResultChecker(BaseResultChecker):
 
     def verify(self):
         if "parameter" in self._config:
-            exit_status, stdout, stderr = self.connection.execute(
-                self.shell_cmd,
-                stdin=open(self.verify_script, "r"))
+            with open(self.verify_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.connection.execute(
+                    self.shell_cmd,
+                    stdin=stdin_file)
             LOG.debug("action script of the operation is: {0}"
                       .format(self.verify_script))
             LOG.debug("action parameter the of operation is: {0}"
                       .format(self.shell_cmd))
         else:
-            exit_status, stdout, stderr = self.connection.execute(
-                "/bin/bash -s ",
-                stdin=open(self.verify_script, "r"))
+            with open(self.verify_script, "r") as stdin_file:
+                exit_status, stdout, stderr = self.connection.execute(
+                    "/bin/bash -s ",
+                    stdin=stdin_file)
             LOG.debug("action script of the operation is: {0}"
                       .format(self.verify_script))