def _execSupervisorServiceAction(self, service_name, action):
"""Perform the action with the run-supervisorctl command.
:return: tuple (exit code, std-output, std-error)
"""
env = get_env_with_bytes_locale()
cmd = os.path.join(snappy.get_snap_path(), "bin", "run-supervisorctl")
cmd = (cmd, action, service_name)
return self._execCmd(cmd, env)
def test__sets_LANG_and_LC_ALL(self):
self.assertThat(
get_env_with_bytes_locale({}),
Equals({
b"LANG": b"C.UTF-8",
b"LANGUAGE": b"C.UTF-8",
b"LC_ALL": b"C.UTF-8",
}),
)
def test__defaults_to_process_environment(self):
name = factory.make_name("name")
value = factory.make_name("value")
with EnvironmentVariable(name, value):
self.assertThat(
get_env_with_bytes_locale(),
ContainsDict(
{name.encode("ascii"): Equals(value.encode("ascii"))}),
)
def test__overwrites_LANGUAGE(self):
self.assertThat(
get_env_with_bytes_locale(
{b"LANGUAGE": factory.make_name("LANGUAGE").encode("ascii")}),
Equals({
b"LANG": b"C.UTF-8",
b"LANGUAGE": b"C.UTF-8",
b"LC_ALL": b"C.UTF-8",
}),
)
def _execSystemDServiceAction(self, service_name, action, extra_opts=None):
"""Perform the action with the systemctl command.
:return: tuple (exit code, std-output, std-error)
"""
env = get_env_with_bytes_locale()
cmd = ["sudo", "--non-interactive", "systemctl", action]
if extra_opts is not None:
cmd.extend(extra_opts)
cmd.append(service_name)
return self._execCmd(cmd, env)
def test__passes_other_variables_through(self):
basis = {
factory.make_name("name").encode("ascii"):
(factory.make_name("value").encode("ascii"))
for _ in range(5)
}
expected = basis.copy()
expected[b"LANG"] = expected[b"LC_ALL"] = expected[b"LANGUAGE"] = (
b"C.UTF-8")
observed = get_env_with_bytes_locale(basis)
self.assertThat(observed, Equals(expected))
def test__removes_other_LC_variables(self):
self.assertThat(
get_env_with_bytes_locale({
name.encode("ascii"): factory.make_name(name).encode("ascii")
for name in LC_VAR_NAMES
}),
Equals({
b"LANG": b"C.UTF-8",
b"LANGUAGE": b"C.UTF-8",
b"LC_ALL": b"C.UTF-8",
}),
)
def test___execSystemDServiceAction_calls_systemctl(self):
service_monitor = self.make_service_monitor()
service_name = factory.make_name("service")
action = factory.make_name("action")
mock_getProcessOutputAndValue = self.patch(
service_monitor_module, "getProcessOutputAndValue")
mock_getProcessOutputAndValue.return_value = succeed((b"", b"", 0))
yield service_monitor._execSystemDServiceAction(service_name, action)
cmd = ["sudo", "--non-interactive", "systemctl", action, service_name]
self.assertThat(
mock_getProcessOutputAndValue, MockCalledOnceWith(
# The environment contains LC_ALL and LANG too.
cmd[0], cmd[1:], env=get_env_with_bytes_locale()))
def _execSupervisorServiceAction(self, service_name, action):
"""Perform the action with the run-supervisorctl command.
:return: tuple (exit code, std-output, std-error)
"""
env = get_env_with_bytes_locale()
cmd = os.path.join(snappy.get_snap_path(), "bin", "run-supervisorctl")
cmd = (cmd, action, service_name)
def decode(result):
out, err, code = result
return code, out.decode("utf-8"), err.decode("utf-8")
d = getProcessOutputAndValue(cmd[0], cmd[1:], env=env)
return d.addCallback(decode)
def _execSystemDServiceAction(self, service_name, action, extra_opts=None):
"""Perform the action with the systemctl command.
:return: tuple (exit code, std-output, std-error)
"""
env = get_env_with_bytes_locale()
cmd = ["sudo", "--non-interactive", "systemctl", action]
if extra_opts is not None:
cmd.extend(extra_opts)
cmd.append(service_name)
def decode(result):
out, err, code = result
return code, out.decode("utf-8"), err.decode("utf-8")
d = getProcessOutputAndValue(cmd[0], cmd[1:], env=env)
return d.addCallback(decode)
def test___execSupervisorServiceAction_calls_supervisorctl(self):
snap_path = factory.make_name("path")
self.patch(snappy, "get_snap_path").return_value = snap_path
service_monitor = self.make_service_monitor()
service_name = factory.make_name("service")
action = factory.make_name("action")
mock_getProcessOutputAndValue = self.patch(
service_monitor_module, "getProcessOutputAndValue")
mock_getProcessOutputAndValue.return_value = succeed((b"", b"", 0))
yield service_monitor._execSupervisorServiceAction(
service_name, action)
cmd = os.path.join(snap_path, 'bin', 'run-supervisorctl')
cmd = cmd, action, service_name
self.assertThat(
mock_getProcessOutputAndValue, MockCalledOnceWith(
# The environment contains LC_ALL and LANG too.
cmd[0], cmd[1:], env=get_env_with_bytes_locale()))
def _execSupervisorServiceAction(self,
service_name,
action,
extra_opts=None):
"""Perform the action with the run-supervisorctl command.
:return: tuple (exit code, std-output, std-error)
"""
env = get_env_with_bytes_locale()
cmd = os.path.join(snap.SnapPaths.from_environ().snap, "bin",
"run-supervisorctl")
# supervisord doesn't support native kill like systemd. Emulate this
# behaviour by getting the PID of the process and then killing the PID.
if action == "kill":
def _kill_pid(result):
exit_code, stdout, _ = result
if exit_code != 0:
return result
try:
pid = int(stdout.strip())
except ValueError:
pid = 0
if pid == 0:
# supervisorctl returns 0 when the process is already dead
# or we where not able to get the actual pid. Nothing to
# do, as its already dead.
return 0, "", ""
cmd = ("kill", )
if extra_opts:
cmd += extra_opts
cmd += ("%s" % pid, )
return self._execCmd(cmd, env)
d = self._execCmd((cmd, "pid", service_name), env)
d.addCallback(_kill_pid)
return d
cmd = (cmd, action)
if extra_opts is not None:
cmd += extra_opts
cmd += (service_name, )
return self._execCmd(cmd, env)