# This file is part of cloud-init. See LICENSE file for license information.
import os
from collections import namedtuple
from io import StringIO
from textwrap import dedent
from cloudinit.atomic_helper import write_json
from cloudinit.cmd import status
from cloudinit.util import ensure_file
from tests.unittests.helpers import CiTestCase, mock, wrap_and_call
mypaths = namedtuple("MyPaths", "run_dir")
myargs = namedtuple("MyArgs", "long wait")
class TestStatus(CiTestCase):
def setUp(self):
super(TestStatus, self).setUp()
self.new_root = self.tmp_dir()
self.status_file = self.tmp_path("status.json", self.new_root)
self.disable_file = self.tmp_path("cloudinit-disable", self.new_root)
self.paths = mypaths(run_dir=self.new_root)
class FakeInit(object):
paths = self.paths
def __init__(self, ds_deps):
pass
def read_cfg(self):
pass
self.init_class = FakeInit
def test__is_cloudinit_disabled_false_on_sysvinit(self):
"""When not in an environment using systemd, return False."""
ensure_file(self.disable_file) # Create the ignored disable file
(is_disabled, reason) = wrap_and_call(
"cloudinit.cmd.status",
{
"uses_systemd": False,
"get_cmdline": "root=/dev/my-root not-important",
},
status._is_cloudinit_disabled,
self.disable_file,
self.paths,
)
self.assertFalse(
is_disabled, "expected enabled cloud-init on sysvinit"
)
self.assertEqual("Cloud-init enabled on sysvinit", reason)
def test__is_cloudinit_disabled_true_on_disable_file(self):
"""When using systemd and disable_file is present return disabled."""
ensure_file(self.disable_file) # Create observed disable file
(is_disabled, reason) = wrap_and_call(
"cloudinit.cmd.status",
{
"uses_systemd": True,
"get_cmdline": "root=/dev/my-root not-important",
},
status._is_cloudinit_disabled,
self.disable_file,
self.paths,
)
self.assertTrue(is_disabled, "expected disabled cloud-init")
self.assertEqual(
"Cloud-init disabled by {0}".format(self.disable_file), reason
)
def test__is_cloudinit_disabled_false_on_kernel_cmdline_enable(self):
"""Not disabled when using systemd and enabled via commandline."""
ensure_file(self.disable_file) # Create ignored disable file
(is_disabled, reason) = wrap_and_call(
"cloudinit.cmd.status",
{
"uses_systemd": True,
"get_cmdline": "something cloud-init=enabled else",
},
status._is_cloudinit_disabled,
self.disable_file,
self.paths,
)
self.assertFalse(is_disabled, "expected enabled cloud-init")
self.assertEqual(
"Cloud-init enabled by kernel command line cloud-init=enabled",
reason,
)
def test__is_cloudinit_disabled_true_on_kernel_cmdline(self):
"""When kernel command line disables cloud-init return True."""
(is_disabled, reason) = wrap_and_call(
"cloudinit.cmd.status",
{
"uses_systemd": True,
"get_cmdline": "something cloud-init=disabled else",
},
status._is_cloudinit_disabled,
self.disable_file,
self.paths,
)
self.assertTrue(is_disabled, "expected disabled cloud-init")
self.assertEqual(
"Cloud-init disabled by kernel parameter cloud-init=disabled",
reason,
)
def test__is_cloudinit_disabled_true_when_generator_disables(self):
"""When cloud-init-generator writes disabled file return True."""
disabled_file = os.path.join(self.paths.run_dir, "disabled")
ensure_file(disabled_file)
(is_disabled, reason) = wrap_and_call(
"cloudinit.cmd.status",
{"uses_systemd": True, "get_cmdline": "something"},
status._is_cloudinit_disabled,
self.disable_file,
self.paths,
)
self.assertTrue(is_disabled, "expected disabled cloud-init")
self.assertEqual("Cloud-init disabled by cloud-init-generator", reason)
def test__is_cloudinit_disabled_false_when_enabled_in_systemd(self):
"""Report enabled when systemd generator creates the enabled file."""
enabled_file = os.path.join(self.paths.run_dir, "enabled")
ensure_file(enabled_file)
(is_disabled, reason) = wrap_and_call(
"cloudinit.cmd.status",
{"uses_systemd": True, "get_cmdline": "something ignored"},
status._is_cloudinit_disabled,
self.disable_file,
self.paths,
)
self.assertFalse(is_disabled, "expected enabled cloud-init")
self.assertEqual(
"Cloud-init enabled by systemd cloud-init-generator", reason
)
def test_status_returns_not_run(self):
"""When status.json does not exist yet, return 'not run'."""
self.assertFalse(
os.path.exists(self.status_file), "Unexpected status.json found"
)
cmdargs = myargs(long=False, wait=False)
with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
retcode = wrap_and_call(
"cloudinit.cmd.status",
{
"_is_cloudinit_disabled": (False, ""),
"Init": {"side_effect": self.init_class},
},
status.handle_status_args,
"ignored",
cmdargs,
)
self.assertEqual(0, retcode)
self.assertEqual("status: not run\n", m_stdout.getvalue())
def test_status_returns_disabled_long_on_presence_of_disable_file(self):
"""When cloudinit is disabled, return disabled reason."""
checked_files = []
def fakeexists(filepath):
checked_files.append(filepath)
status_file = os.path.join(self.paths.run_dir, "status.json")
return bool(not filepath == status_file)
cmdargs = myargs(long=True, wait=False)
with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
retcode = wrap_and_call(
"cloudinit.cmd.status",
{
"os.path.exists": {"side_effect": fakeexists},
"_is_cloudinit_disabled": (
True,
"disabled for some reason",
),
"Init": {"side_effect": self.init_class},
},
status.handle_status_args,
"ignored",
cmdargs,
)
self.assertEqual(0, retcode)
self.assertEqual(
[os.path.join(self.paths.run_dir, "status.json")], checked_files
)
expected = dedent(
"""\
status: disabled
detail:
disabled for some reason
"""
)
self.assertEqual(expected, m_stdout.getvalue())
def test_status_returns_running_on_no_results_json(self):
"""Report running when status.json exists but result.json does not."""
result_file = self.tmp_path("result.json", self.new_root)
write_json(self.status_file, {})
self.assertFalse(
os.path.exists(result_file), "Unexpected result.json found"
)
cmdargs = myargs(long=False, wait=False)
with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
retcode = wrap_and_call(
"cloudinit.cmd.status",
{
"_is_cloudinit_disabled": (False, ""),
"Init": {"side_effect": self.init_class},
},
status.handle_status_args,
"ignored",
cmdargs,
)
self.assertEqual(0, retcode)
self.assertEqual("status: running\n", m_stdout.getvalue())
def test_status_returns_running(self):
"""Report running when status exists with an unfinished stage."""
ensure_file(self.tmp_path("result.json", self.new_root))
write_json(
self.status_file, {"v1": {"init": {"start": 1, "finished": None}}}
)
cmdargs = myargs(long=False, wait=False)
with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
retcode = wrap_and_call(
"cloudinit.cmd.status",
{
"_is_cloudinit_disabled": (False, ""),
"Init": {"side_effect": self.init_class},
},
status.handle_status_args,
"ignored",
cmdargs,
)
self.assertEqual(0, retcode)
self.assertEqual("status: running\n", m_stdout.getvalue())
def test_status_returns_done(self):
"""Report done results.json exists no stages are unfinished."""
ensure_file(self.tmp_path("result.json", self.new_root))
write_json(
self.status_file,
{
"v1": {
"stage": None, # No current stage running
"datasource": (
"DataSourceNoCloud [seed=/var/.../seed/nocloud-net]"
"[dsmode=net]"
),
"blah": {"finished": 123.456},
"init": {
"errors": [],
"start": 124.567,
"finished": 125.678,
},
"init-local": {"start": 123.45, "finished": 123.46},
}
},
)
cmdargs = myargs(long=False, wait=False)
with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
retcode = wrap_and_call(
"cloudinit.cmd.status",
{
"_is_cloudinit_disabled": (False, ""),
"Init": {"side_effect": self.init_class},
},
status.handle_status_args,
"ignored",
cmdargs,
)
self.assertEqual(0, retcode)
self.assertEqual("status: done\n", m_stdout.getvalue())
def test_status_returns_done_long(self):
"""Long format of done status includes datasource info."""
ensure_file(self.tmp_path("result.json", self.new_root))
write_json(
self.status_file,
{
"v1": {
"stage": None,
"datasource": (
"DataSourceNoCloud [seed=/var/.../seed/nocloud-net]"
"[dsmode=net]"
),
"init": {"start": 124.567, "finished": 125.678},
"init-local": {"start": 123.45, "finished": 123.46},
}
},
)
cmdargs = myargs(long=True, wait=False)
with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
retcode = wrap_and_call(
"cloudinit.cmd.status",
{
"_is_cloudinit_disabled": (False, ""),
"Init": {"side_effect": self.init_class},
},
status.handle_status_args,
"ignored",
cmdargs,
)
self.assertEqual(0, retcode)
expected = dedent(
"""\
status: done
time: Thu, 01 Jan 1970 00:02:05 +0000
detail:
DataSourceNoCloud [seed=/var/.../seed/nocloud-net][dsmode=net]
"""
)
self.assertEqual(expected, m_stdout.getvalue())
def test_status_on_errors(self):
"""Reports error when any stage has errors."""
write_json(
self.status_file,
{
"v1": {
"stage": None,
"blah": {"errors": [], "finished": 123.456},
"init": {
"errors": ["error1"],
"start": 124.567,
"finished": 125.678,
},
"init-local": {"start": 123.45, "finished": 123.46},
}
},
)
cmdargs = myargs(long=False, wait=False)
with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
retcode = wrap_and_call(
"cloudinit.cmd.status",
{
"_is_cloudinit_disabled": (False, ""),
"Init": {"side_effect": self.init_class},
},
status.handle_status_args,
"ignored",
cmdargs,
)
self.assertEqual(1, retcode)
self.assertEqual("status: error\n", m_stdout.getvalue())
def test_status_on_errors_long(self):
"""Long format of error status includes all error messages."""
write_json(
self.status_file,
{
"v1": {
"stage": None,
"datasource": (
"DataSourceNoCloud [seed=/var/.../seed/nocloud-net]"
"[dsmode=net]"
),
"init": {
"errors": ["error1"],
"start": 124.567,
"finished": 125.678,
},
"init-local": {
"errors": ["error2", "error3"],
"start": 123.45,
"finished": 123.46,
},
}
},
)
cmdargs = myargs(long=True, wait=False)
with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
retcode = wrap_and_call(
"cloudinit.cmd.status",
{
"_is_cloudinit_disabled": (False, ""),
"Init": {"side_effect": self.init_class},
},
status.handle_status_args,
"ignored",
cmdargs,
)
self.assertEqual(1, retcode)
expected = dedent(
"""\
status: error
time: Thu, 01 Jan 1970 00:02:05 +0000
detail:
error1
error2
error3
"""
)
self.assertEqual(expected, m_stdout.getvalue())
def test_status_returns_running_long_format(self):
"""Long format reports the stage in which we are running."""
write_json(
self.status_file,
{
"v1": {
"stage": "init",
"init": {"start": 124.456, "finished": None},
"init-local": {"start": 123.45, "finished": 123.46},
}
},
)
cmdargs = myargs(long=True, wait=False)
with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
retcode = wrap_and_call(
"cloudinit.cmd.status",
{
"_is_cloudinit_disabled": (False, ""),
"Init": {"side_effect": self.init_class},
},
status.handle_status_args,
"ignored",
cmdargs,
)
self.assertEqual(0, retcode)
expected = dedent(
"""\
status: running
time: Thu, 01 Jan 1970 00:02:04 +0000
detail:
Running in stage: init
"""
)
self.assertEqual(expected, m_stdout.getvalue())
def test_status_wait_blocks_until_done(self):
"""Specifying wait will poll every 1/4 second until done state."""
running_json = {
"v1": {
"stage": "init",
"init": {"start": 124.456, "finished": None},
"init-local": {"start": 123.45, "finished": 123.46},
}
}
done_json = {
"v1": {
"stage": None,
"init": {"start": 124.456, "finished": 125.678},
"init-local": {"start": 123.45, "finished": 123.46},
}
}
self.sleep_calls = 0
def fake_sleep(interval):
self.assertEqual(0.25, interval)
self.sleep_calls += 1
if self.sleep_calls == 2:
write_json(self.status_file, running_json)
elif self.sleep_calls == 3:
write_json(self.status_file, done_json)
result_file = self.tmp_path("result.json", self.new_root)
ensure_file(result_file)
cmdargs = myargs(long=False, wait=True)
with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
retcode = wrap_and_call(
"cloudinit.cmd.status",
{
"sleep": {"side_effect": fake_sleep},
"_is_cloudinit_disabled": (False, ""),
"Init": {"side_effect": self.init_class},
},
status.handle_status_args,
"ignored",
cmdargs,
)
self.assertEqual(0, retcode)
self.assertEqual(4, self.sleep_calls)
self.assertEqual("....\nstatus: done\n", m_stdout.getvalue())
def test_status_wait_blocks_until_error(self):
"""Specifying wait will poll every 1/4 second until error state."""
running_json = {
"v1": {
"stage": "init",
"init": {"start": 124.456, "finished": None},
"init-local": {"start": 123.45, "finished": 123.46},
}
}
error_json = {
"v1": {
"stage": None,
"init": {
"errors": ["error1"],
"start": 124.456,
"finished": 125.678,
},
"init-local": {"start": 123.45, "finished": 123.46},
}
}
self.sleep_calls = 0
def fake_sleep(interval):
self.assertEqual(0.25, interval)
self.sleep_calls += 1
if self.sleep_calls == 2:
write_json(self.status_file, running_json)
elif self.sleep_calls == 3:
write_json(self.status_file, error_json)
cmdargs = myargs(long=False, wait=True)
with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
retcode = wrap_and_call(
"cloudinit.cmd.status",
{
"sleep": {"side_effect": fake_sleep},
"_is_cloudinit_disabled": (False, ""),
"Init": {"side_effect": self.init_class},
},
status.handle_status_args,
"ignored",
cmdargs,
)
self.assertEqual(1, retcode)
self.assertEqual(4, self.sleep_calls)
self.assertEqual("....\nstatus: error\n", m_stdout.getvalue())
def test_status_main(self):
"""status.main can be run as a standalone script."""
write_json(
self.status_file, {"v1": {"init": {"start": 1, "finished": None}}}
)
with self.assertRaises(SystemExit) as context_manager:
with mock.patch("sys.stdout", new_callable=StringIO) as m_stdout:
wrap_and_call(
"cloudinit.cmd.status",
{
"sys.argv": {"new": ["status"]},
"_is_cloudinit_disabled": (False, ""),
"Init": {"side_effect": self.init_class},
},
status.main,
)
self.assertEqual(0, context_manager.exception.code)
self.assertEqual("status: running\n", m_stdout.getvalue())
# vi: ts=4 expandtab syntax=python