subprocess.Popen -> cmk.utils.cmk_subprocess.Popen (1)

Change-Id: Id87f1940c2bffc38893909cf408df4c76ca425c2

agents/special/agent_ibmsvc

@@ -31,7 +31,7 @@ from __future__ import print_function
 import os
 import sys
 import getopt
-import subprocess
+import cmk.utils.cmk_subprocess as subprocess
 
 
 def usage():
@@ -234,18 +234,25 @@ if opt_debug:
     sys.stderr.write("executing external command: %s\n" % cmd)
 
 result = subprocess.Popen(  # nosec
-    cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=None)
+    cmd,
+    shell=True,
+    stdout=subprocess.PIPE,
+    stderr=subprocess.PIPE,
+    stdin=None,
+    encoding="utf-8",
+)
 stdout, stderr = result.communicate()
 exit_code = result.wait()
 
 if exit_code not in [0, 1]:
-    sys.stderr.write("Error connecting via ssh: %s\n" % stderr)
+    msg = "Error connecting via ssh: %s\n" % stderr
+    sys.stderr.write(msg.encode("utf-8"))
     sys.exit(2)
 
 lines = stdout.split('\n')
 
 if lines[0].startswith("CMMVC7016E") or (len(lines) > 1 and lines[1].startswith("CMMVC7016E")):
-    sys.stderr.write(stdout)
+    sys.stderr.write(stdout.encode("utf-8"))
     sys.exit(2)
 
 # Quite strange.. Why not simply print stdout?

agents/special/agent_ipmi_sensors

@@ -28,7 +28,7 @@ import os
 import errno
 import sys
 import getopt
-import subprocess
+import cmk.utils.cmk_subprocess as subprocess
 
 
 def agent_ipmi_sensors_usage():
@@ -75,9 +75,9 @@ def parse_data(data, excludes):
                     has_excludes = True
                     break
             if not has_excludes:
-                sys.stdout.write("%s\n" % line)
+                sys.stdout.write(("%s\n" % line).encode("utf-8"))
         else:
-            sys.stdout.write("%s\n" % line)
+            sys.stdout.write(("%s\n" % line).encode("utf-8"))
 
 
 def agent_ipmi_sensors_main(cmdline_args):
@@ -179,12 +179,14 @@ def agent_ipmi_sensors_main(cmdline_args):
         sys.stdout.write("<<<ipmi%s:sep(124)>>>\n" % section)
         try:
             try:
-                p = subprocess.Popen(ipmi_cmd + types,
-                                     shell=False,
-                                     close_fds=True,
-                                     stdin=open(os.devnull),
-                                     stdout=subprocess.PIPE,
-                                     stderr=subprocess.PIPE)
+                p = subprocess.Popen(
+                    ipmi_cmd + types,
+                    close_fds=True,
+                    stdin=open(os.devnull),
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    encoding="utf-8",
+                )
             except OSError as e:
                 if e.errno == errno.ENOENT:  # No such file or directory
                     raise Exception("Could not find '%s' command (PATH: %s)"\
@@ -200,7 +202,8 @@ def agent_ipmi_sensors_main(cmdline_args):
             errors.append(e)
 
     if errors:
-        sys.stderr.write("ERROR: '%s'.\n" % ", ".join(errors))
+        msg = "ERROR: '%s'.\n" % ", ".join(errors)
+        sys.stderr.write(msg.encode("utf-8"))
         sys.exit(1)
 
     sys.exit(0)

agents/windows/it/remote.py

@@ -1,14 +1,13 @@
 #!/usr/bin/env python
 # -*- coding: utf-8; py-indent-offset: 4 -*-
 import ConfigParser
-import contextlib
 import os
 import platform
-import pytest
 import re
-import subprocess
 import sys
 import telnetlib  # nosec
+import pytest
+import cmk.utils.cmk_subprocess as subprocess
 
 # To use another host for running the tests, replace this IP address.
 remote_ip = '10.1.2.30'
@@ -24,17 +23,22 @@
 
 def run_subprocess(cmd):
     sys.stderr.write(' '.join(cmd) + '\n')
-    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    p = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        encoding="utf-8",
+    )
     stdout, stderr = p.communicate()
     return (p.returncode, stdout, stderr)
 
 
 def assert_subprocess(cmd):
     exit_code, stdout, stderr = run_subprocess(cmd)
     if stdout:
-        sys.stdout.write(stdout)
+        sys.stdout.write(stdout.encode("utf-8"))
     if stderr:
-        sys.stderr.write(stderr)
+        sys.stderr.write(stderr.encode("utf-8"))
     assert exit_code == 0, "'%s' failed" % ' '.join(cmd)
 
 

agents/windows/it/test_section_check_mk.py

@@ -4,11 +4,12 @@
 import platform
 import pytest
 import re
-import subprocess
 from remote import (actual_output, agent_exe, config, remotetest, remotedir, wait_agent,
                     write_config)
 import sys
 
+import cmk.utils.cmk_subprocess as subprocess
+
 
 class Globals(object):
     output_file = 'agentoutput.txt'
@@ -46,12 +47,15 @@ def actual_output_no_tcp(request, write_config):
         try:
             save_cwd = os.getcwd()
             os.chdir(remotedir)
-            p = subprocess.Popen([agent_exe] + request.param,
-                                 stdout=subprocess.PIPE,
-                                 stderr=subprocess.PIPE)
+            p = subprocess.Popen(
+                [agent_exe] + request.param,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                encoding="utf-8",
+            )
             stdout, stderr = p.communicate()
-            sys.stdout.write(stdout)
-            sys.stderr.write(stderr)
+            sys.stdout.write(stdout.encode("utf-8"))
+            sys.stderr.write(stderr.encode("utf-8"))
             assert p.returncode == 0
             if request.param[0] == 'file':
                 with open(Globals.output_file) as outfile:

agents/wnx/integration/local.py

@@ -11,13 +11,14 @@
 import pytest
 import re
 import time
-import subprocess
 import sys
 import shutil
 import telnetlib  # nosec
 import it_utils
 import platform
 
+import cmk.utils.cmk_subprocess as subprocess
+
 default_config = """
 global:
   enabled: true
@@ -146,7 +147,12 @@ def env_var(key, value):
 def run_subprocess(cmd):
     with env_var('CMA_TEST_DIR', root_dir):
         sys.stderr.write(' '.join(cmd) + '\n')
-        p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        p = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            encoding="cp1252",
+        )
         stdout, stderr = p.communicate(timeout=10)
 
     return p.returncode, stdout, stderr
@@ -163,10 +169,10 @@ def assert_subprocess(cmd):
     exit_code, stdout_ret, stderr_ret = run_subprocess(cmd)
 
     if stdout_ret:
-        sys.stdout.write(stdout_ret.decode(encoding='cp1252'))
+        sys.stdout.write(stdout_ret.encode("cp1252"))
 
     if stderr_ret:
-        sys.stderr.write(stderr_ret.decode(encoding='cp1252'))
+        sys.stderr.write(stderr_ret.encode("cp1252"))
 
     assert exit_code == 0, "'%s' failed" % ' '.join(cmd)
 

bin/mkbackup

@@ -37,7 +37,6 @@ import re
 import shutil
 import socket
 import signal
-import subprocess
 import sys
 import syslog
 import tempfile
@@ -59,6 +58,8 @@ import cmk.utils.schedule as schedule
 import cmk.utils.store as store
 from cmk.utils.exceptions import MKTerminate, MKGeneralException
 
+import cmk.utils.cmk_subprocess as subprocess
+
 VERSION = "1.4.0i1"
 
 
@@ -111,7 +112,8 @@ def stop_logging():
 
 
 def log(s):
-    sys.stdout.write("%s %s\n" % (time.strftime("%Y-%m-%d %H:%M:%S"), s))
+    msg = "%s %s\n" % (time.strftime("%Y-%m-%d %H:%M:%S"), s)
+    sys.stdout.write(msg.encode("utf-8"))
     if is_cma():
         syslog.syslog(s)
 
@@ -697,12 +699,15 @@ def start_site(site):
 def omd_command(*args):
     cmd = ["omd"] + list(args)
     verbose("Command: %s" % " ".join(cmd))
-    p = subprocess.Popen(cmd,
-                         stdout=subprocess.PIPE,
-                         stderr=subprocess.STDOUT,
-                         stdin=open(os.devnull),
-                         close_fds=True)
-    stdout = p.communicate()[0]
+    p = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        stdin=open(os.devnull),
+        close_fds=True,
+        encoding="utf-8",
+    )
+    stdout, _stderr = p.communicate()
     verbose(stdout)
     if p.returncode != 0:
         raise MKGeneralException("Failed to run <tt>%s</tt>: %s" % (" ".join(cmd), stdout))

bin/mkbench

@@ -69,7 +69,6 @@ import logging
 import tempfile
 import threading
 import traceback
-import subprocess
 import collections
 import multiprocessing
 import six
@@ -84,6 +83,7 @@ from cmk.utils.exceptions import (
     MKGeneralException,
     MKTerminate,
 )
+import cmk.utils.cmk_subprocess as subprocess
 
 #.
 #   .--Helpers-------------------------------------------------------------.
@@ -517,11 +517,14 @@ class TestRunner(threading.Thread):
         with open("%s/etc/rrdcached.conf" % omd_root(), "w") as f:
             f.write("TIMEOUT=300\n" "RANDOM_DELAY=10\n" "FLUSH_TIMEOUT=7200\n" "WRITE_THREADS=4\n")
 
-        p = subprocess.Popen(["omd", "restart", "rrdcached"],
-                             close_fds=True,
-                             stdout=subprocess.PIPE,
-                             stderr=subprocess.STDOUT)
-        stdout = p.communicate()[0]
+        p = subprocess.Popen(
+            ["omd", "restart", "rrdcached"],
+            close_fds=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            encoding="utf-8",
+        )
+        stdout, _stderr = p.communicate()
         if p.returncode != 0:
             raise MKGeneralException("Failed to restart rrdcached: %s" % stdout)
 
@@ -2693,14 +2696,17 @@ class TestAgentBasedStandardHosts(TestCase):
             shutil.copy(src_file, "%s/%s.mk" % (autochecks_dir, host_name))
 
     def _discover_services_of_host(self, host_name):
-        p = subprocess.Popen(["cmk", "-II", host_name],
-                             stdin=open(os.devnull),
-                             close_fds=True,
-                             stdout=subprocess.PIPE,
-                             stderr=subprocess.STDOUT)
+        p = subprocess.Popen(
+            ["cmk", "-II", host_name],
+            stdin=open(os.devnull),
+            close_fds=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            encoding="utf-8",
+        )
 
         try:
-            stdout = p.communicate()[0]
+            stdout, _stderr = p.communicate()
         except KeyboardInterrupt:
             try:
                 p.terminate()
@@ -2785,14 +2791,17 @@ class TestAgentBasedStandardHosts(TestCase):
     def _create_rrds_of_host(self, host_name):
         # Do 2 iterations to initialize the rrds that base on counter values
         for _i in xrange(2):
-            p = subprocess.Popen(["cmk", "-v", host_name],
-                                 stdin=open(os.devnull),
-                                 close_fds=True,
-                                 stdout=subprocess.PIPE,
-                                 stderr=subprocess.STDOUT)
+            p = subprocess.Popen(
+                ["cmk", "-v", host_name],
+                stdin=open(os.devnull),
+                close_fds=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                encoding="utf-8",
+            )
 
             try:
-                stdout = p.communicate()[0]
+                stdout, _stderr = p.communicate()
             except KeyboardInterrupt:
                 try:
                     p.terminate()
@@ -2824,13 +2833,16 @@ class TestAgentBasedStandardHosts(TestCase):
     def _activate_changes(self):
         if self._test:
             self._test.info("  Activating changes")
-        p = subprocess.Popen(["cmk", "-R"],
-                             close_fds=True,
-                             stdout=subprocess.PIPE,
-                             stderr=subprocess.STDOUT)
+        p = subprocess.Popen(
+            ["cmk", "-R"],
+            close_fds=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            encoding="utf-8",
+        )
 
         try:
-            stdout = p.communicate()[0]
+            stdout, _stderr = p.communicate()
         except KeyboardInterrupt:
             try:
                 p.terminate()